Built with
Alectryon , running Coq+SerAPI v8.15.0+0.15.0. Bubbles (
) indicate interactive fragments: hover for details, tap to reveal contents. Use
Ctrl+↑ Ctrl+↓ to navigate,
Ctrl+🖱️ to focus. On Mac, use
⌘ instead of
Ctrl .
Require Export prosa.analysis.definitions.task_schedule.Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "_ + _" was already used in scope nat_scope.
[notation-overridden,parsing]Notation "_ - _" was already used in scope nat_scope.
[notation-overridden,parsing]Notation "_ <= _" was already used in scope nat_scope.
[notation-overridden,parsing]Notation "_ < _" was already used in scope nat_scope.
[notation-overridden,parsing]Notation "_ >= _" was already used in scope nat_scope.
[notation-overridden,parsing]Notation "_ > _" was already used in scope nat_scope.
[notation-overridden,parsing]Notation "_ <= _ <= _" was already used in scope
nat_scope. [notation-overridden,parsing]Notation "_ < _ <= _" was already used in scope
nat_scope. [notation-overridden,parsing]Notation "_ <= _ < _" was already used in scope
nat_scope. [notation-overridden,parsing]Notation "_ < _ < _" was already used in scope
nat_scope. [notation-overridden,parsing]Notation "_ * _" was already used in scope nat_scope.
[notation-overridden,parsing]
Require Export prosa.analysis.facts.model.rbf.Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Export prosa.analysis.facts.model.task_arrivals.Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Export prosa.analysis.facts.model.sequential.Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Export prosa.analysis.abstract .abstract_rta.Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
(** * 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. *)
(** We prove that the maximum among the solutions of the response-time bound
recurrence for some set of parameters is a response-time bound for [tsk].
Note that in this section we _do_ rely on the hypothesis about task
sequentiality. This allows us to provide a more precise response-time
bound function, since jobs of the same task will be executed strictly
in the order they arrive. *)
Section Sequential_Abstract_RTA .
(** Consider any type of tasks ... *)
Context {Task : TaskType}.
Context `{TaskCost Task}.
Context `{TaskRunToCompletionThreshold Task}.
(** ... and any type of jobs associated with these tasks. *)
Context {Job : JobType}.
Context `{JobTask Job Task}.
Context `{JobArrival Job}.
Context `{JobCost Job}.
Context `{JobPreemptable Job}.
(** Consider any arrival sequence with consistent, non-duplicate arrivals... *)
Variable arr_seq : arrival_sequence Job.
Hypothesis H_arrival_times_are_consistent : consistent_arrival_times arr_seq.
Hypothesis H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq.
(** Next, consider any 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.
(** ... 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.
(** Assume that the job costs are no larger than the task costs. *)
Hypothesis H_valid_job_cost :
arrivals_have_valid_job_costs arr_seq.
(** Consider an arbitrary task set. *)
Variable ts : list Task.
(** Let [tsk] be any task in ts that is to be analyzed. *)
Variable tsk : Task.
Hypothesis H_tsk_in_ts : tsk \in ts.
(** Consider a valid preemption model... *)
Hypothesis H_valid_preemption_model :
valid_preemption_model arr_seq sched.
(** ...and a valid task run-to-completion threshold function. That
is, [task_rtct tsk] is (1) no bigger than [tsk]'s cost, (2) for
any job of task [tsk] [job_rtct] is bounded by [task_rtct]. *)
Hypothesis H_valid_run_to_completion_threshold :
valid_task_run_to_completion_threshold arr_seq tsk.
(** 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.
(** Assume we are provided with abstract functions for interference and interfering workload. *)
Variable interference : Job -> instant -> bool.
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.
(** In this section, we introduce a few new definitions to make it easier
to express the new bound of the worst-case execution time. *)
Section Definitions .
(** 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 :=
forall (j : Job) (t1 t2 : instant),
arrives_in arr_seq j ->
job_of_task tsk j ->
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).
(** 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.
(** 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) :=
forall j R t1 t2 ,
arrives_in arr_seq j ->
job_of_task tsk j ->
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]. *)
Section ResponseTimeBound .
(** 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.
(** We assume that the schedule is work-conserving. *)
Hypothesis H_work_conserving :
work_conserving arr_seq sched tsk interference interfering_workload.
(** 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 arr_seq sched.
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.
(** 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.
(** 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 Δ.
(** 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 + ε, Δ)]. *)
Let is_in_search_space_seq := is_in_search_space tsk L total_interference_bound.
(** 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 :
forall (A : duration),
is_in_search_space_seq A ->
exists (F : duration),
A + F >= (task_rbf (A + ε) - (task_cost tsk - task_rtct tsk))
+ task_interference_bound_function tsk A (A + F) /\
R >= F + (task_cost tsk - task_rtct tsk).
(** 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. *)
Section CompletionOfJobsFromSameTask .
(** 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_of_task tsk j1.
Hypothesis H_j2_from_tsk : job_of_task tsk j2.
Hypothesis H_j1_cost_positive : job_cost_positive j1.
(** Consider the busy interval <<[t1, t2)>> of job j1. *)
Variable t1 t2 : instant.
Hypothesis H_busy_interval : busy_interval j1 t1 t2.
(** 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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
move => JA; move : (H_j2_from_tsk) => /eqP TSK2eq.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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
rewrite /completed_by.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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
job_cost j2 <= service sched j2 t1
move : (posnP (@job_cost _ H3 j2)) => [-> | POS]; first by done .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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
job_cost j2 <= service sched j2 t1
move : (H_interference_and_workload_consistent_with_sequential_tasks j1 t1 t2) => SWEQ.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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 j2SWEQ : arrives_in arr_seq j1 ->
job_of_task tsk j1 ->
0 < job_cost j1 ->
busy_interval j1 t1 t2 ->
task_workload_between 0 t1 =
task_service_of_jobs_in
(arrivals_between 0 t1) 0 t1
job_cost j2 <= service sched j2 t1
feed_n 4 SWEQ; try by done . Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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 j2SWEQ : task_workload_between 0 t1 =
task_service_of_jobs_in
(arrivals_between 0 t1) 0 t1
job_cost j2 <= service sched j2 t1
apply all_jobs_have_completed_equiv_workload_eq_service with (j := j2) in SWEQ => //.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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 j2SWEQ : task_workload_between 0 t1 =
task_service_of_jobs_in
(arrivals_between 0 t1) 0 t1 H6 : unit_service_proc_model (processor_state Job) ->
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 : pred Job) (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
unit_service_proc_model (processor_state Job)
- Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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 j2SWEQ : task_workload_between 0 t1 =
task_service_of_jobs_in
(arrivals_between 0 t1) 0 t1 H6 : unit_service_proc_model (processor_state Job) ->
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 : pred Job) (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
unit_service_proc_model (processor_state Job)
by apply ideal_proc_model_provides_unit_service.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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 j2SWEQ : task_workload_between 0 t1 =
task_service_of_jobs_in
(arrivals_between 0 t1) 0 t1 H6 : unit_service_proc_model (processor_state Job) ->
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 : pred Job) (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
- Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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 j2SWEQ : task_workload_between 0 t1 =
task_service_of_jobs_in
(arrivals_between 0 t1) 0 t1 H6 : unit_service_proc_model (processor_state Job) ->
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 : pred Job) (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.
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 :
forall t ,
t1 <= t ->
pending sched j2 t ->
arrived_between j2 t1 t.+1 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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 t.+1
Proof .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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 t.+1
intros t GE PEND.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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 t.+1
rewrite /arrived_between; apply /andP; split ; last first .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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 < t.+1
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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 < t.+1
by move : PEND => /andP [ARR _]; rewrite ltnS. } Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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 _]] _].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj1, j2 : Job H_j1_arrives : arrives_in arr_seq j1 H_j2_arrives : arrives_in arr_seq j2 H_j1_from_tsk : job_of_task tsk j1 H_j2_from_tsk : job_of_task tsk j2 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].
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. *)
Section BoundOfCumulativeJobInterference .
(** Consider any job [j] of [tsk]. *)
Variable j : Job.
Hypothesis H_j_arrives : arrives_in arr_seq j.
Hypothesis H_job_of_tsk : job_of_task tsk j.
Hypothesis H_job_cost_positive : job_cost_positive j.
(** Consider the busy interval <<[t1, t2)>> of job j. *)
Variable t1 t2 : instant.
Hypothesis H_busy_interval : busy_interval j t1 t2.
(** Let's define A as a relative arrival time of job j (with respect to time t1). *)
Let A : duration := job_arrival j - t1.
(** Consider an arbitrary time x ... *)
Variable x : duration.
(** ... such that (t1 + x) is inside the busy interval... *)
Hypothesis H_inside_busy_interval : t1 + x < t2.
(** ... and job j is not completed by time (t1 + x). *)
Hypothesis H_job_j_is_not_completed : ~~ completed_by sched j (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. *)
Section TaskInterferenceBoundsInterference .
(** 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. *)
Section CaseAnalysis .
(** Consider an arbitrary time instant t ∈ <<[t1, t1 + x)>>. *)
Variable t : instant.
Hypothesis H_t_in_interval : t1 <= t < t1 + x.
Section Case1 .
(** Assume the processor is idle at time [t]. *)
Hypothesis H_idle : sched t = None.
(** 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
move : (H_busy_interval) => [[/andP [BUS LT] _] _].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_(j <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk j)
service_at sched j t +
~~
match sched t with
| Some j => job_task j == tsk
| None => false
end &&
has (interference^~ t)
(task_arrivals_before arr_seq tsk t2)
erewrite eq_bigr; last by move => i j' /=; rewrite service_at_def H_idle /=.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_(i <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk i)
(fun => 0 ) i +
~~
match sched t with
| Some j => job_task j == tsk
| None => false
end &&
has (interference^~ t)
(task_arrivals_before arr_seq tsk t2)
rewrite /= big1_eq add0n H_idle addn0.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 <=
~~ false &&
has (interference^~ t)
(task_arrivals_before arr_seq tsk t2)
case INT: (interference j t); last by done .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 <=
~~ false &&
has (interference^~ t)
(task_arrivals_before arr_seq tsk t2)
rewrite /= lt0b.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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; exists j ; last by done .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
rewrite mem_filter; apply /andP; split ; first by done .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 arrival_sequence.arrivals_between arr_seq 0 t2
by apply arrived_between_implies_in_arrivals.
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_of_task tsk j'.
(** 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk 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
move : (H_busy_interval) => [[/andP [BUS LT] _] _].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk 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/=.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' BUS : t1 <= job_arrival j LT : job_arrival j < t2
interference j t + (sched t == Some j) <=
\sum_(j <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk j)
service_at sched j t +
~~
match sched t with
| Some j => job_task j == 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk 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_(j <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk j)
service_at sched j t +
~~
match sched t with
| Some j => job_task j == tsk
| None => false
end &&
has (interference^~ t)
(task_arrivals_before arr_seq tsk t2)
rewrite H_sched H_not_job_of_tsk; simpl .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' BUS : t1 <= job_arrival j LT : job_arrival j < t2 ARRs : arrives_in arr_seq j'
interference j t + (Some j' == Some j) <=
\sum_(j <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk j)
service_at sched j t +
has (interference^~ t)
(task_arrivals_before arr_seq tsk t2)
have ->: Some j' == Some j = false; last rewrite addn0.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' BUS : t1 <= job_arrival j LT : job_arrival j < t2 ARRs : arrives_in arr_seq j'
(Some j' == Some j) = false
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' BUS : t1 <= job_arrival j LT : job_arrival j < t2 ARRs : arrives_in arr_seq j'
(Some j' == Some j) = false
apply /negP => /eqP CONTR; inversion CONTR; subst j'.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_not_job_of_tsk : ~~ job_of_task tsk j H_sched : sched t = Some j BUS : t1 <= job_arrival j LT : job_arrival j < t2 CONTR : Some j = Some j ARRs : arrives_in arr_seq j
False
by move : (H_not_job_of_tsk); rewrite H_job_of_tsk. } Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' BUS : t1 <= job_arrival j LT : job_arrival j < t2 ARRs : arrives_in arr_seq j'
interference j t <=
\sum_(j <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk j)
service_at sched j t +
has (interference^~ t)
(task_arrivals_before arr_seq tsk t2)
erewrite eq_bigr; last by move => i _; rewrite service_at_def H_sched.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' BUS : t1 <= job_arrival j LT : job_arrival j < t2 ARRs : arrives_in arr_seq j'
interference j t <=
\sum_(i <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk i)
(fun i0 : Job => nat_of_bool (Some j' == Some i0))
i +
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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 => j2 TSK.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' BUS : t1 <= job_arrival j LT : job_arrival j < t2 ARRs : arrives_in arr_seq j' j2 : Job TSK : job_task j2 == tsk
(Some j' == Some j2) = 0
apply /eqP; rewrite eqb0; apply /negP => /eqP EQ; inversion EQ; subst j'.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j2 : Job H_not_job_of_tsk : ~~ job_of_task tsk j2 H_sched : sched t = Some j2 BUS : t1 <= job_arrival j LT : job_arrival j < t2 ARRs : arrives_in arr_seq j2 TSK : job_task j2 == tsk EQ : Some j2 = Some j2
False
by move : (H_not_job_of_tsk); rewrite / job_of_task TSK.
} Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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_(i <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk i)
(Some j' == Some i) +
has (interference^~ t)
(task_arrivals_before arr_seq tsk t2)
rewrite {}ZERO ?addn0 add0n /=.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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)
rewrite /= lt0b.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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; exists j ; last by done .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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
rewrite mem_filter; apply /andP; split ; first by done .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' BUS : t1 <= job_arrival j LT : job_arrival j < t2 ARRs : arrives_in arr_seq j' INT : interference j t = true
j \in arrival_sequence.arrivals_between arr_seq 0 t2
by eapply arrived_between_implies_in_arrivals.
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_of_task tsk j'.
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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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
move : (H_busy_interval) => [[/andP [BUS LT] _] _].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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/=.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' H_j_neq_j' : j != j' BUS : t1 <= job_arrival j LT : job_arrival j < t2
interference j t + (sched t == Some j) <=
\sum_(j <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk j)
service_at sched j t +
~~
match sched t with
| Some j => job_task j == 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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_(j <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk j)
service_at sched j t +
~~
match sched t with
| Some j => job_task j == tsk
| None => false
end &&
has (interference^~ t)
(task_arrivals_before arr_seq tsk t2)
move : (H_not_job_of_tsk) => /eqP; rewrite H_sched => ->; rewrite eq_refl addn0; simpl .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 + (Some j' == Some j) <=
\sum_(j <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk j)
service_at sched j t
have ->: Some j' == Some j = false by
apply /negP => /eqP EQ; inversion EQ; subst j'; move :H_j_neq_j' => /negP NEQ; apply : NEQ.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 + false <=
\sum_(j <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk j)
service_at sched j t
replace (interference j t) with true; last first .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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). } Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 _].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 move : CONTR; rewrite H_sched => /eqP EQ; inversion EQ; subst ; move : H_j_neq_j' => /eqP.
} Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' H_j_neq_j' : j != j' BUS : t1 <= job_arrival j LT : job_arrival j < t2 ARRs : arrives_in arr_seq j'
true + false <=
\sum_(j <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk j)
service_at sched j t
rewrite big_mkcond; apply /sum_seq_gt0P; exists j' ; split ; last first .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 service_at sched j' t
else 0 )
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 service_at sched j' t
else 0 )
move : H_not_job_of_tsk => /eqP TSK.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' H_j_neq_j' : j != j' BUS : t1 <= job_arrival j LT : job_arrival j < t2 ARRs : arrives_in arr_seq j' TSK : job_task j' = tsk
0 <
(if job_of_task tsk j'
then service_at sched j' t
else 0 )
by rewrite /job_of_task TSK eq_refl service_at_def H_sched eq_refl. } Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 + ε)
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 + ε)
have ARR:= arrives_after_beginning_of_busy_interval j j' _ _ _ _ _ t1 t2 _ t.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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_of_task tsk j ->
job_of_task tsk j' ->
job_cost_positive j ->
busy_interval j t1 t2 ->
t1 <= t ->
pending sched j' t -> arrived_between j' t1 t.+1
j' \in arrivals_between t1 (t1 + A + ε)
feed_n 8 ARR; try (done || by move : H_t_in_interval => /andP [T1 T2]). Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 t.+1
pending sched j' t
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 t.+1
pending sched j' t
move : H_sched => /eqP SCHEDt.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 t.+1 SCHEDt : sched t == Some j'
pending sched j' t
apply scheduled_implies_pending;
auto using ideal_proc_model_ensures_ideal_progress.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 t.+1 SCHEDt : sched t == Some j'
scheduled_at sched j' t
by rewrite scheduled_at_def. } Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 t.+1
j' \in arrivals_between t1 (t1 + A + ε)
case_eq (job_arrival j' <= job_arrival j) => ARRNEQ.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 t.+1 ARRNEQ : (job_arrival j' <= job_arrival j) = true
j' \in arrivals_between t1 (t1 + A + ε)
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 t.+1 ARRNEQ : (job_arrival j' <= job_arrival j) = true
j' \in arrivals_between t1 (t1 + A + ε)
move : ARR => /andP [РР _].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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. } Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 t.+1 ARRNEQ : (job_arrival j' <= job_arrival j) = false
j' \in arrivals_between t1 (t1 + A + ε)
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 t.+1 ARRNEQ : (job_arrival j' <= job_arrival j) = false
j' \in arrivals_between t1 (t1 + A + ε)
exfalso .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 t.+1 ARRNEQ : (job_arrival j' <= job_arrival j) = false
False
apply negbT in ARRNEQ; rewrite -ltnNge in ARRNEQ.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 t.+1 ARRNEQ : job_arrival j < job_arrival j'
False
move : (H_sequential_tasks j j' t) => CONTR.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 t.+1 ARRNEQ : job_arrival j < job_arrival j' CONTR : arrives_in arr_seq j ->
arrives_in arr_seq j' ->
same_task j j' ->
job_arrival j < job_arrival j' ->
scheduled_at sched j' t ->
completed_by sched j t
False
feed_n 5 CONTR; try done . Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 t.+1 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'
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 t.+1 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; move : (H_job_of_tsk) => /eqP ->. } Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 t.+1 ARRNEQ : job_arrival j < job_arrival j' CONTR : scheduled_at sched j' t ->
completed_by sched j t
scheduled_at sched j' t
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 t.+1 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. } Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 t.+1 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 t.+1 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_of_task tsk j' 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 t.+1 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]. } }
Qed .
End Case3 .
Section Case4 .
(** Assume that job [j] is scheduled at time [t]. *)
Hypothesis H_sched : sched t = Some j.
(** 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
have j_is_in_arrivals_between: j \in arrivals_between t1 (t1 + A + ε).Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 + ε)
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 _] [_ _]] _].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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.
} Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_(j <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk j)
service_at sched j t +
~~
match sched t with
| Some j => job_task j == tsk
| None => false
end &&
has (interference^~ t)
(task_arrivals_before arr_seq tsk t2)
rewrite H_sched; move : H_job_of_tsk => /eqP ->; rewrite eq_refl eq_refl addn0 //=.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 + 1 <=
\sum_(j <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk j)
service_at sched j t
move : (H_work_conserving j _ _ t H_j_arrives H_job_of_tsk H_job_cost_positive H_busy_interval) => WORK.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 + 1 <=
\sum_(j <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk j)
service_at sched j t
feed WORK. Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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). } Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 + 1 <=
\sum_(j <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk j)
service_at sched j t
move : WORK => [_ ZIJT].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 + 1 <=
\sum_(j <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk j)
service_at sched j t
feed ZIJT; first by rewrite scheduled_at_def H_sched; simpl . Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 + 1 <=
\sum_(j <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk j)
service_at sched j t
move : ZIJT => /negP /eqP; rewrite eqb_negLR; simpl ; move => /eqP ZIJT; rewrite ZIJT; simpl ; rewrite add0n.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
0 <
\sum_(j <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk j)
service_at sched j t
rewrite big_mkcond //=; apply /sum_seq_gt0P.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 service_at sched i t
else 0 )
exists j ; split ; first by apply j_is_in_arrivals_between.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
0 <
(if job_of_task tsk j then service_at sched j t else 0 )
by move : (H_job_of_tsk) => ->; rewrite service_at_def H_sched eq_refl.
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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
move : (H_busy_interval) => [[/andP [BUS LT] _] _].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 | ].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
2 : by apply interference_plus_sched_le_serv_of_task_plus_task_interference_idle.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
2 : by eapply interference_plus_sched_le_serv_of_task_plus_task_interference_task; [eassumption | apply /negbT].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 | ].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
1 : by apply interference_plus_sched_le_serv_of_task_plus_task_interference_j.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 .
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).Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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)
have j_is_in_arrivals_between: j \in arrivals_between t1 (t1 + A + ε).Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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 + ε)
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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 _] [_ _]] _].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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.
} Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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 //=.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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 <= j < t1 + x)
\sum_(i <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk i)
service_at sched i j -
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)).Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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 <= j < t1 + x)
\sum_(i <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk i)
service_at sched i j -
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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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 <= j < t1 + x)
\sum_(i <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk i)
service_at sched i j
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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 <= j < t1 + x)
\sum_(i <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk i)
service_at sched i j
rewrite (exchange_big _ _ (arrivals_between _ _)) /= (big_rem j) //=.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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 <=
(if job_of_task tsk j
then \sum_(t1 <= i < t1 + x) service_at sched j i
else 0 ) +
\sum_(y <- rem (T:=Job) j
(arrivals_between t1 (t1 + A + ε)) |
job_of_task tsk y)
\sum_(t1 <= i < t1 + x) service_at sched y i
by rewrite H_job_of_tsk leq_addr. } Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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 <= j < t1 + x)
\sum_(i <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk i)
service_at sched i j +
cumul_task_interference t2 t1 (t1 + x)
rewrite -big_split -big_split //=.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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 + service_at sched j i) <=
\sum_(t1 <= i < t1 + x)
(\sum_(i0 <- arrivals_between t1 (t1 + A + ε) |
job_of_task tsk i0) service_at sched i0 i +
task_interference_received_before tsk t2 i)
rewrite big_nat_cond [X in _ <= X]big_nat_cond leq_sum //; move => t /andP [NEQ _].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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 + service_at sched j t <=
\sum_(i <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk i)
service_at sched i t +
task_interference_received_before tsk t2 t
rewrite {1 }service_at_def -scheduled_at_def.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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)
service_at sched i t +
task_interference_received_before tsk t2 t
by apply interference_plus_sched_le_serv_of_task_plus_task_interference.
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).Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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)
have j_is_in_arrivals_between: j \in arrivals_between t1 (t1 + A + ε).Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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 + ε)
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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 _] [_ _]] _].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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.
} Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_(j <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk j)
service_during sched j 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j
then service_during sched j t1 (t1 + x)
else 0 ) +
\sum_(y <- rem (T:=Job) j
(arrivals_between t1 (t1 + A + ε)) |
job_of_task tsk y) 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 H_job_of_tsk addnC -addnBA; last by done .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk y) 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_of_task
tsk y)
job_cost y - job_cost j
rewrite [X in _ <= X - _]addnC -addnBA; last by done .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk y) 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_of_task
tsk y)
job_cost y + (job_cost j - job_cost j)
rewrite !subnn !addn0.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk y) service_during sched y t1 (t1 + x) <=
\sum_(y <- rem (T:=Job) j
(arrival_sequence.arrivals_between
arr_seq t1 (t1 + A + ε)) | job_of_task
tsk y)
job_cost y
by apply service_of_jobs_le_workload; auto using ideal_proc_model_provides_unit_service.
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).Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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)
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].
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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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
move : H_j_arrives H_job_of_tsk H_busy_interval => ARR TSK [[/andP [JAGET1 JALTT2] _] _].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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).Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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. } Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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 + ε).Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j JAGET1 : t1 <= job_arrival j JALTT2 : job_arrival j < t2
j \in arrivals_between (t1 + A) (t1 + A + ε)
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j JAGET1 : t1 <= job_arrival j JALTT2 : job_arrival j < t2
arrived_between j (t1 + A) (t1 + A + ε)
apply /andP; split ; rewrite /A subnKC //.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j JAGET1 : t1 <= job_arrival j JALTT2 : job_arrival j < t2
job_arrival j < job_arrival j + ε
by rewrite addn1 ltnSn //. } Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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).Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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)
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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). } Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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 + ε).Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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 + ε)
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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 j <- \cat_(t1 + A<=t<t1 + A + ε)
arrivals_at arr_seq t
| job_of_task tsk j]
by rewrite size_filter -has_count; apply /hasP; exists j ; last rewrite TSK.
} Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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 //.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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 + ε).Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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 + ε)
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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. } Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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 + ε)
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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 (big_rem j) //= TSK leq_addr. } Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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 + ε)
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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 . } Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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 | ].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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_(j <- \cat_(t1 + A<=t<t1 + A + ε)
arrivals_at arr_seq t | job_of_task tsk j)
job_cost j - job_cost j <=
task_cost tsk *
size
[seq j <- \cat_(t1 + A<=t<t1 + A + ε)
arrivals_at arr_seq t
| job_of_task tsk j] - task_cost tsk
rewrite {1 }addn1 big_nat1 addn1 big_nat1.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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_(j <- arrivals_at arr_seq (t1 + A) | job_of_task
tsk j)
job_cost j - job_cost j <=
task_cost tsk *
size
[seq j <- arrivals_at arr_seq (t1 + A)
| job_of_task tsk j] - task_cost tsk
rewrite (big_rem j) //= TSK //= addnC -addnBA // subnn addn0.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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_of_task
tsk y)
job_cost y <=
task_cost tsk *
size
[seq j <- arrivals_at arr_seq (t1 + A)
| job_of_task tsk j] - task_cost tsk
rewrite (filter_size_rem j); [ | by done | by rewrite TSK].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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_of_task
tsk y)
job_cost y <=
task_cost tsk *
(size
[seq y <- rem (T:=Job) j
(arrivals_at arr_seq (t1 + A))
| job_of_task tsk y] + 1 ) - task_cost tsk
rewrite mulnDr mulnC muln1 -addnBA // subnn addn0 mulnC.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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_of_task
tsk y)
job_cost y <=
task_cost tsk *
size
[seq y <- rem (T:=Job) j
(arrivals_at arr_seq (t1 + A))
| job_of_task tsk y]
apply sum_majorant_constant.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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_of_task tsk a -> job_cost a <= task_cost tsk
move => j' ARR' /eqP TSK2.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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_of_task tsk j 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; exists (t1 + A); apply rem_in in ARR'.
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).Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : instant H_busy_interval : busy_interval j t1 t2 A := job_arrival 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)
set (y := t1 + x) in *.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : 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 + ε).Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : 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 + ε)
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : 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 _] _] _].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : 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.
} Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : 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).Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : 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
- Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : 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
by apply cumulative_job_interference_le_task_interference_bound.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : 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
- Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : 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 .
Qed .
End BoundOfCumulativeJobInterference .
(** In this section, we prove that [H_R_is_maximum_seq] implies [H_R_is_maximum]. *)
Section MaxInSeqHypothesisImpMaxInNonseqHypothesis .
(** Consider any job [j] of [tsk]. *)
Variable j : Job.
Hypothesis H_j_arrives : arrives_in arr_seq j.
Hypothesis H_job_of_tsk : job_of_task tsk j.
(** For simplicity, let's define a local name for the search space. *)
Let is_in_search_space A :=
is_in_search_space tsk L total_interference_bound A.
(** We prove that [H_R_is_maximum] holds. *)
Lemma max_in_seq_hypothesis_implies_max_in_nonseq_hypothesis :
forall (A : duration),
is_in_search_space A ->
exists (F : duration),
A + F >= task_rtct tsk +
(task_rbf (A + ε) - task_cost tsk + task_interference_bound_function tsk A (A + F)) /\
R >= F + (task_cost tsk - task_rtct tsk).Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : 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,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j 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,
task_rtct tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) <=
A + F /\ F + (task_cost tsk - task_rtct tsk) <= R
Proof .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : 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,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j 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,
task_rtct tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) <=
A + F /\ F + (task_cost tsk - task_rtct tsk) <= R
move : H_valid_run_to_completion_threshold => [PRT1 PRT2].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : 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,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j 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,
task_rtct tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) <=
A + F /\ F + (task_cost tsk - task_rtct tsk) <= R
intros A INSP.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : 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,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j 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,
task_rtct tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) <=
A + F /\ F + (task_cost tsk - task_rtct tsk) <= R
clear H_sequential_tasks H_interference_and_workload_consistent_with_sequential_tasks.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_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,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j 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,
task_rtct tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) <=
A + F /\ F + (task_cost tsk - task_rtct tsk) <= R
move : (H_R_is_maximum_seq _ INSP) => [F [FIX LE]].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_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,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j 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 : task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function tsk A (A + F) <=
A + F LE : F + (task_cost tsk - task_rtct tsk) <= R
exists F : duration,
task_rtct tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) <=
A + F /\ F + (task_cost tsk - task_rtct tsk) <= R
exists F ; split ; last by done .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_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,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j 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 : task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function tsk A (A + F) <=
A + F LE : F + (task_cost tsk - task_rtct tsk) <= R
task_rtct tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) <=
A + F
rewrite -{2 }(leqRW FIX).Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_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,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j 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 : task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function tsk A (A + F) <=
A + F LE : F + (task_cost tsk - task_rtct tsk) <= R
task_rtct tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) <=
task_rbf (A + ε) - (task_cost tsk - task_rtct tsk) +
task_interference_bound_function tsk A (A + F)
rewrite addnA leq_add2r.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_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,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j 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 : task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function tsk A (A + F) <=
A + F LE : F + (task_cost tsk - task_rtct tsk) <= R
task_rtct tsk + (task_rbf (A + ε) - task_cost tsk) <=
task_rbf (A + ε) - (task_cost tsk - task_rtct tsk)
rewrite addnBA; last first .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_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,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j 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 : task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function tsk A (A + F) <=
A + F LE : F + (task_cost tsk - task_rtct tsk) <= R
task_cost tsk <= task_rbf (A + ε)
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_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,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j 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 : task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function tsk A (A + F) <=
A + F LE : F + (task_cost tsk - task_rtct tsk) <= R
task_cost tsk <= task_rbf (A + ε)
apply leq_trans with (task_rbf 1 ).Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_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,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j 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 : task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function tsk A (A + F) <=
A + F LE : F + (task_cost tsk - task_rtct tsk) <= R
task_cost tsk <= task_rbf 1
eapply task_rbf_1_ge_task_cost; eauto 2 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_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,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j 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 : task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function tsk A (A + F) <=
A + F LE : F + (task_cost tsk - task_rtct tsk) <= R
task_rbf 1 <= task_rbf (A + ε)
eapply task_rbf_monotone; eauto 2 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_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,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j 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 : task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function tsk A (A + F) <=
A + F LE : F + (task_cost tsk - task_rtct tsk) <= R
0 < A + ε
by rewrite addn1.
} Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_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,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j 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 : task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function tsk A (A + F) <=
A + F LE : F + (task_cost tsk - task_rtct tsk) <= R
task_rtct tsk + task_rbf (A + ε) - task_cost tsk <=
task_rbf (A + ε) - (task_cost tsk - task_rtct tsk)
by rewrite subnBA; auto ; rewrite addnC.
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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
R
response_time_bounded_by tsk R
Proof .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
R
response_time_bounded_by tsk R
intros j ARR TSK.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job ARR : arrives_in arr_seq j TSK : job_of_task tsk j
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); eauto 2 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job ARR : arrives_in arr_seq j TSK : job_of_task tsk j
ideal_progress_proc_model (processor_state Job)
apply ideal_proc_model_ensures_ideal_progress.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job ARR : arrives_in arr_seq j TSK : job_of_task tsk j
unit_service_proc_model (processor_state Job)
apply ideal_proc_model_provides_unit_service.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job ARR : arrives_in arr_seq j TSK : job_of_task tsk j
job_interference_is_bounded_by arr_seq sched tsk
interference interfering_workload
(fun (tsk : Task) (A : nat) (R : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A R)
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job ARR : arrives_in arr_seq j TSK : job_of_task tsk j
job_interference_is_bounded_by arr_seq sched tsk
interference interfering_workload
(fun (tsk : Task) (A : nat) (R : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A R)
clear ARR TSK H_R_is_maximum_seq R j.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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 (tsk : Task) (A : nat) (R : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A R)
intros t1 t2 R j BUSY NEQ ARR TSK COMPL.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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_of_task tsk j 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].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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_of_task tsk j 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
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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_of_task tsk j 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 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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_of_task tsk j 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.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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_of_task tsk j 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.
} Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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_of_task tsk j 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 *.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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_of_task tsk j 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 jA := 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)).Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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_of_task tsk j 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 jA := 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)
- Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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_of_task tsk j 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 jA := 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)
by eapply cumulative_job_interference_bound; eauto 2 .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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_of_task tsk j 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 jA := 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
- Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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_of_task tsk j 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 jA := 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.
} Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job ARR : arrives_in arr_seq j TSK : job_of_task tsk j
forall A : nat,
is_in_search_space tsk L
(fun (tsk : Task) (A0 : nat) (R : duration) =>
task_rbf (A0 + ε) - task_cost tsk +
task_interference_bound_function tsk A0 R) A ->
exists F : nat,
task_rtct tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) <=
A + F /\ F + (task_cost tsk - task_rtct tsk) <= R
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts interference : Job -> instant -> bool interfering_workload : Job -> instant -> duration task_rbf := task_request_bound_function tsk : duration -> nat busy_interval := definitions.busy_interval sched
interference interfering_workload : Job -> instant -> instant -> Prop arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat task_workload_between := workload.task_workload_between
arr_seq tsk : instant -> instant -> nat task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in
sched tsk : seq Job ->
instant -> instant -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop cumul_interference := definitions.cumul_interference
interference : Job -> nat -> nat -> nat cumul_workload := cumul_interfering_workload
interfering_workload : Job -> nat -> nat -> nat cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat H_work_conserving : work_conserving arr_seq sched tsk
interference
interfering_workload H_sequential_tasks : sequential_tasks arr_seq sched H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk
interference
interfering_workload L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : nat H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk) +
task_interference_bound_function
tsk A (A + F) <=
A + F /\
F +
(task_cost tsk - task_rtct tsk) <=
Rj : Job ARR : arrives_in arr_seq j TSK : job_of_task tsk j
forall A : nat,
is_in_search_space tsk L
(fun (tsk : Task) (A0 : nat) (R : duration) =>
task_rbf (A0 + ε) - task_cost tsk +
task_interference_bound_function tsk A0 R) A ->
exists F : nat,
task_rtct tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) <=
A + F /\ F + (task_cost tsk - task_rtct tsk) <= R
by eapply max_in_seq_hypothesis_implies_max_in_nonseq_hypothesis; eauto . }
Qed .
End ResponseTimeBound .
End Sequential_Abstract_RTA .