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 .ideal.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 valid arrival sequence with consistent, non-duplicate arrivals...*)
Variable arr_seq : arrival_sequence Job.
Hypothesis H_valid_arrival_sequence : valid_arrival_sequence arr_seq.
(** ... and any ideal 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. *)
Context `{Interference Job}.
Context `{InterferingWorkload Job}.
(** Let's define some local names for clarity. *)
Let task_rbf := task_request_bound_function tsk.
Let arrivals_between := arrivals_between arr_seq.
Let service_of_jobs_at := service_of_jobs_at sched.
(** In this section, we introduce a few new definitions to make it
easier to express the new bound on the worst-case interference. *)
Section Definitions .
(** When assuming sequential tasks, we can introduce an additional
hypothesis that ensures that the values of interference and
workload remain consistent. It is important to note that
before a busy interval of a job [j] of task [tsk] begins, both
the cumulative task workload and task service must be equal
within the interval <<[0, t1)>>. This has an implication that
a busy interval for job [j] cannot begin if there is another
pending job of the same task [tsk]. This requirement makes
sense only in the context of sequential tasks. *)
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 sched j t1 t2 ->
task_workload_between arr_seq tsk 0 t1 = task_service_of_jobs_in sched tsk (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) (t__up : instant) (t : instant) :=
~ task_scheduled_at sched tsk t /\
exists j , interference j t /\ j \in task_arrivals_before arr_seq tsk t__up.
(** We also define a decidable counterpart of this definition... *)
Definition task_interference_received_before_dec (tsk : Task) (t__up : instant) (t : instant) :=
(~~ task_scheduled_at sched tsk t)
&& has (fun j => interference j t) (task_arrivals_before arr_seq tsk t__up).
(** ... and prove that the propositional and decidable definitions
are equivalent. *)
Lemma task_interference_received_before_P :
forall tsk t__up t , reflect (task_interference_received_before tsk t__up t)
(task_interference_received_before_dec tsk t__up 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat
forall (tsk : Task) (t__up t : instant),
reflect
(task_interference_received_before tsk t__up t)
(task_interference_received_before_dec tsk t__up 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat
forall (tsk : Task) (t__up t : instant),
reflect
(task_interference_received_before tsk t__up t)
(task_interference_received_before_dec tsk t__up t)
clear task_rbf H_valid_run_to_completion_threshold H_tsk_in_ts 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_valid_preemption_model : valid_preemption_model
arr_seq sched H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat
forall (tsk : Task) (t__up t : instant),
reflect
(task_interference_received_before tsk t__up t)
(task_interference_received_before_dec tsk t__up t)
move => tsk t__up t; apply /introP => TI.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_valid_preemption_model : valid_preemption_model
arr_seq sched H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat tsk : Task t__up, t : instant TI : task_interference_received_before_dec tsk t__up t
task_interference_received_before tsk t__up 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_valid_preemption_model : valid_preemption_model
arr_seq sched H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat tsk : Task t__up, t : instant TI : task_interference_received_before_dec tsk t__up t
task_interference_received_before tsk t__up t
move : TI => /andP [T1 /hasP [j IN INT]].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_valid_preemption_model : valid_preemption_model
arr_seq sched H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat tsk : Task t__up, t : instant T1 : ~~ task_scheduled_at sched tsk t j : Job IN : j \in task_arrivals_before arr_seq tsk t__up INT : interference j t
task_interference_received_before tsk t__up t
by split ; [apply /negP | exists 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_valid_preemption_model : valid_preemption_model
arr_seq sched H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat tsk : Task t__up, t : instant TI : ~~
task_interference_received_before_dec tsk t__up t
~ task_interference_received_before tsk t__up 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_valid_preemption_model : valid_preemption_model
arr_seq sched H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat tsk : Task t__up, t : instant TI : ~~
task_interference_received_before_dec tsk t__up t
~ task_interference_received_before tsk t__up t
move => [NS [j [INT 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_valid_preemption_model : valid_preemption_model
arr_seq sched H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat tsk : Task t__up, t : instant TI : ~~
task_interference_received_before_dec tsk t__up t NS : ~ task_scheduled_at sched tsk t j : Job INT : interference j t IN : j \in task_arrivals_before arr_seq tsk t__up
False
move : TI => /negP TI; apply : TI.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_valid_preemption_model : valid_preemption_model
arr_seq sched H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat tsk : Task t__up, t : instant NS : ~ task_scheduled_at sched tsk t j : Job INT : interference j t IN : j \in task_arrivals_before arr_seq tsk t__up
task_interference_received_before_dec tsk t__up t
by apply /andP; split ; [apply /negP | apply /hasP; exists j ].
Qed .
(** Next we define the cumulative task interference. *)
Definition cumul_task_interference tsk upper_bound t1 t2 :=
\sum_(t1 <= t < t2) task_interference_received_before_dec tsk upper_bound t.
(** We say that task interference is bounded by
[task_interference_bound_function] ([task_IBF]) iff for any
job [j] of task [tsk] cumulative _task_ interference within
the interval [t1, t1 + R) is bounded by function
[task_IBF(tsk, A, R)]. Note that this definition is almost
the same as the definition of [job_interference_is_bounded_by]
from the non-necessarily-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 sched 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 .
(** We assume that the schedule is work-conserving. *)
Hypothesis H_work_conserving : work_conserving arr_seq sched.
(** Unlike the previous theorem
[uniprocessor_response_time_bound_ideal], 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] that 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 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 + task_IBF 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 : duration.
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 sched 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j1 t1 t2 JA : job_arrival j2 < t1 TSK2eq : job_task j2 = tsk
completed_by sched j2 t1
move : (posnP (@job_cost _ H3 j2)) => [ZERO|POS].Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j1 t1 t2 JA : job_arrival j2 < t1 TSK2eq : job_task j2 = tsk ZERO : job_cost j2 = 0
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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j1 t1 t2 JA : job_arrival j2 < t1 TSK2eq : job_task j2 = tsk ZERO : job_cost j2 = 0
completed_by sched j2 t1
by rewrite /completed_by /service.completed_by ZERO. } Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j1 t1 t2 JA : job_arrival j2 < t1 TSK2eq : job_task j2 = tsk POS : 0 < job_cost j2
completed_by sched j2 t1
move : (H_interference_and_workload_consistent_with_sequential_tasks
j1 t1 t2 H_j1_arrives H_j1_from_tsk H_j1_cost_positive H_busy_interval) => SWEQ.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j1 t1 t2 JA : job_arrival j2 < t1 TSK2eq : job_task j2 = tsk POS : 0 < job_cost j2SWEQ : task_workload_between arr_seq tsk 0 t1 =
task_service_of_jobs_in sched tsk
(arrivals_between 0 t1) 0 t1
completed_by sched j2 t1
eapply all_jobs_have_completed_equiv_workload_eq_service with (j := j2) in SWEQ; rt_eauto.
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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j1 t1 t2
forall t : nat,
t1 <= t ->
pending sched j2 t -> arrived_between j2 t1 t.+1
move => 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j1 t1 t2 t : nat GE : t1 <= t PEND : pending sched j2 t
t1 <= job_arrival j2
rewrite leqNgt; apply /negP; move => 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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 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_ideal] 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 sched 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 that
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_dec 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_dec 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_dec 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_dec tsk t2 t
replace (service_of_jobs_at _ _ _) with 0 ; 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
0 =
service_of_jobs_at (job_of_task tsk)
(arrivals_between t1 (t1 + A + ε)) 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
0 =
service_of_jobs_at (job_of_task tsk)
(arrivals_between t1 (t1 + A + ε)) t
symmetry ; rewrite /service_of_jobs_at /service_of_jobs.service_of_jobs_at /=.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
\sum_(j <- arrivals_between t1 (t1 + A + ε) | job_of_task
tsk j)
service_at sched j t = 0
by eapply big1; move => 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 <=
0 + task_interference_received_before_dec tsk t2 t
rewrite /service_of_jobs.service_of_jobs_at /service_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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) <=
0 + task_interference_received_before_dec tsk t2 t
rewrite !H_idle/= 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 <=
task_interference_received_before_dec tsk t2 t
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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 <= task_interference_received_before_dec tsk t2 t
rewrite /= lt0b /task_interference_received_before_dec; apply /andP; 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
~~ task_scheduled_at sched tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
~~ task_scheduled_at sched tsk t
by rewrite /task_scheduled_at 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x H_idle : sched t = None BUS : t1 <= job_arrival j LT : job_arrival j < t2 INT : interference j t = true
j \in task_arrivals_before arr_seq tsk t2
by rewrite mem_filter; apply /andP; split ; rt_eauto.
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_dec 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) 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_dec 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) 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_dec 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) 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_dec tsk t2 t
rewrite /task_interference_received_before_dec
/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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) 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
by rewrite mem_filter; apply /andP; split ; rt_eauto.
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 : scheduled_at sched j' t.
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_dec 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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_dec 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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_dec 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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_dec tsk t2 t
have ->: scheduled_at sched j t = 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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
scheduled_at sched j t = 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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
scheduled_at sched j t = false
move : H_sched; rewrite !scheduled_at_def => /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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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
(Some j' == Some j) = false
apply /eqP; move => 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_j_neq_j' : j != j H_not_job_of_tsk : job_of_task tsk j H_sched : scheduled_at sched j t BUS : t1 <= job_arrival j LT : job_arrival j < t2 EQ : Some j = Some j
False
by move : (H_j_neq_j') => /eqP EQj; apply : EQj. } Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 + false <=
service_of_jobs_at (job_of_task tsk)
(arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before_dec tsk t2 t
have ->: interference j t = true.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 = true
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 = true
have NEQT: 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 NEQT : t1 <= t < t2
interference j t = true
move : (H_work_conserving j t1 t2 t H_j_arrives H_job_cost_positive (fst 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 NEQT : t1 <= t < t2 Hn : ~ interference j t ->
receives_service_at sched j t
interference j t = true
apply /negPn/negP; move => 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 NEQT : t1 <= t < t2 Hn : ~ interference j t ->
receives_service_at sched j t CONTR : ~ interference j t
False
apply Hn, service_at_implies_scheduled_at 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 NEQT : t1 <= t < t2 Hn : ~ interference j t ->
receives_service_at sched j t CONTR : scheduled_at sched j t
False
move : H_j_neq_j' => /negP JJ; apply : JJ.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 NEQT : t1 <= t < t2 Hn : ~ interference j t ->
receives_service_at sched j t CONTR : scheduled_at sched j t
j == j'
by apply /eqP; eapply ideal_proc_model_is_a_uniprocessor_model; rt_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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
true + false <=
service_of_jobs_at (job_of_task tsk)
(arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before_dec tsk t2 t
rewrite leq_add //= /service_of_jobs_at /service_of_jobs.service_of_jobs_at big_mkcond sum_nat_gt0.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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
has
(fun x : Job =>
0 <
(if job_of_task tsk x
then service_at sched x t
else 0 ))
[seq _ <- arrivals_between t1 (t1 + A + ε) | true]
apply /hasP.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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
exists2 x : Job,
x
\in [seq _ <- arrivals_between t1 (t1 + A + ε)
| true] &
0 <
(if job_of_task tsk x
then service_at sched x t
else 0 )
exists j' ; 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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
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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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
0 <
(if job_of_task tsk j'
then service_at sched j' t
else 0 )
by move : H_not_job_of_tsk => /eqP TSK; rewrite /job_of_task TSK eq_refl service_at_is_scheduled_at 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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
j'
\in [seq _ <- arrivals_between t1 (t1 + A + ε)
| true]
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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
j'
\in [seq _ <- arrivals_between t1 (t1 + A + ε)
| true]
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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 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 sched j t1 t2 ->
t1 <= t ->
pending sched j' t -> arrived_between j' t1 t.+1
j'
\in [seq _ <- arrivals_between t1 (t1 + A + ε)
| true]
feed_n 8 ARR; rt_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 ARR : t1 <= t ->
pending sched j' t -> arrived_between j' t1 t.+1
t1 <= 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 ARR : t1 <= t ->
pending sched j' t -> arrived_between j' t1 t.+1
t1 <= t
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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 ARR : pending sched j' t -> arrived_between j' t1 t.+1
pending sched j' t
by move : H_sched => /eqP SCHEDt; apply scheduled_implies_pending; rt_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 ARR : arrived_between j' t1 t.+1
j'
\in [seq _ <- arrivals_between t1 (t1 + A + ε)
| true]
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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 ARR : arrived_between j' t1 t.+1 ARRNEQ : (job_arrival j' <= job_arrival j) = true
j'
\in [seq _ <- arrivals_between t1 (t1 + A + ε)
| true]
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 ARR : arrived_between j' t1 t.+1 ARRNEQ : (job_arrival j' <= job_arrival j) = true
j'
\in [seq _ <- arrivals_between t1 (t1 + A + ε)
| true]
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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 ARRNEQ : (job_arrival j' <= job_arrival j) = true РР : t1 <= job_arrival j'
j'
\in [seq _ <- arrivals_between t1 (t1 + A + ε)
| true]
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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 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; rt_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 ARR : arrived_between j' t1 t.+1 ARRNEQ : (job_arrival j' <= job_arrival j) = false
j'
\in [seq _ <- arrivals_between t1 (t1 + A + ε)
| true]
{ Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 ARR : arrived_between j' t1 t.+1 ARRNEQ : (job_arrival j' <= job_arrival j) = false
j'
\in [seq _ <- arrivals_between t1 (t1 + A + ε)
| true]
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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 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; rt_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x) t : instant H_t_in_interval : t1 <= t < t1 + x j' : Job H_sched : scheduled_at sched j' t 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 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_dec 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_dec 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_dec 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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; rt_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_dec tsk t2 t
rewrite /task_interference_received_before_dec
/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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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)
move : (H_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 + ε) TSK : job_task j = tsk
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 TSK !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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 + ε) TSK : job_task j = tsk
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_cost_positive (fst 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 + ε) TSK : job_task j = tsk WORK : t1 <= t < t2 ->
~ interference j t <->
receives_service_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 + ε) TSK : job_task j = tsk WORK : t1 <= t < t2 ->
~ interference j t <->
receives_service_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 + ε) TSK : job_task j = tsk WORK : t1 <= t < t2 ->
~ interference j t <->
receives_service_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 + ε) TSK : job_task j = tsk WORK : t1 <= t < t2 ->
~ interference j t <->
receives_service_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 + ε) TSK : job_task j = tsk WORK : ~ interference j t <->
receives_service_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 + ε) TSK : job_task j = tsk ZIJT : receives_service_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. Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 + ε) TSK : job_task j = tsk ZIJT : receives_service_at sched j t ->
~ interference j t
receives_service_at sched j t
by apply ideal_proc_model_ensures_ideal_progress;
rewrite scheduled_in_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 + ε) TSK : job_task j = tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 + ε) TSK : job_task j = tsk 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 //= sum_nat_gt0 filter_predT; apply /hasP.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 + ε) TSK : job_task j = tsk ZIJT : interference j t = false
exists2 x : Job,
x \in arrivals_between t1 (t1 + A + ε) &
0 <
(if job_of_task tsk x
then service_at sched x t
else 0 )
exists j ; 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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 + ε) TSK : job_task j = tsk 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_dec 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_dec 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_dec 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_dec tsk t2 t
case SCHEDt: (sched t) => [j1 | ];
last 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_dec tsk t2 t
have ARRs: arrives_in arr_seq j1
by move : SCHEDt => /eqP; rewrite -scheduled_at_def; rt_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_dec tsk t2 t
case_eq (job_task j1 == tsk) => TSK;
last 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_dec tsk t2 t
case EQ: (j == j1); [move : EQ => /eqP EQ; subst j1 | ];
first 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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_dec tsk t2 t
eapply interference_plus_sched_le_serv_of_task_plus_task_interference_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
scheduled_at sched ?j' t
by rewrite scheduled_at_def; apply /eqP; apply 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
job_of_task tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
job_of_task tsk j1
by rt_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
j != 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + 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
j != j1
by move : EQ => /eqP EQ; apply /eqP.
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 :
cumulative_interference j t1 (t1 + x)
<= (task_service_of_jobs_in sched tsk (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x)
- service_during sched j t1 (t1 + x)) + cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x)
cumulative_interference j t1 (t1 + x) <=
task_service_of_jobs_in sched tsk
(arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) +
cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x)
cumulative_interference j t1 (t1 + x) <=
task_service_of_jobs_in sched tsk
(arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) +
cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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; rt_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 + ε)
cumulative_interference j t1 (t1 + x) <=
task_service_of_jobs_in sched tsk
(arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) +
cumul_task_interference tsk t2 t1 (t1 + x)
rewrite /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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 + ε)
cumulative_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 tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 + ε)
cumulative_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 tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 + ε)
cumulative_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 tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_dec 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_dec 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_dec 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 sched tsk (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x)
- service_during sched j t1 (t1 + x) + cumul_task_interference tsk t2 t1 (t1 + x)
<= (task_workload_between arr_seq tsk t1 (t1 + A + ε) - job_cost j)
+ cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 sched tsk
(arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) +
cumul_task_interference tsk t2 t1 (t1 + x) <=
task_workload_between arr_seq tsk t1 (t1 + A + ε) -
job_cost j +
cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 sched tsk
(arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) +
cumul_task_interference tsk t2 t1 (t1 + x) <=
task_workload_between arr_seq tsk t1 (t1 + A + ε) -
job_cost j +
cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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; rt_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 sched tsk
(arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) +
cumul_task_interference tsk t2 t1 (t1 + x) <=
task_workload_between arr_seq tsk t1 (t1 + A + ε) -
job_cost j +
cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 sched tsk
(arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) <=
task_workload_between arr_seq tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 arr_seq tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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; rt_eauto.
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 :
cumulative_interference j t1 (t1 + x)
<= (task_workload_between arr_seq tsk t1 (t1 + A + ε) - job_cost j)
+ cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x)
cumulative_interference j t1 (t1 + x) <=
task_workload_between arr_seq tsk t1 (t1 + A + ε) -
job_cost j +
cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x)
cumulative_interference j t1 (t1 + x) <=
task_workload_between arr_seq tsk t1 (t1 + A + ε) -
job_cost j +
cumul_task_interference tsk t2 t1 (t1 + x)
by apply leq_trans with
(task_service_of_jobs_in sched tsk (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x)
- service_during sched j t1 (t1 + x)
+ cumul_task_interference tsk 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 on the cumulative
interference, we need to abandon the actual workload in
favor of a bound that depends on task parameters only. So,
we show that the actual workload of the task excluding workload
of any job [j] is no greater than the bound on the workload
excluding the cost of job [j]'s task. *)
Lemma task_rbf_excl_tsk_bounds_task_workload_excl_j :
task_workload_between arr_seq tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 arr_seq tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 arr_seq tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 arr_seq tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 arr_seq tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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; rt_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 arr_seq tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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)
have CONSISTENT : consistent_arrival_times arr_seq by rt_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 + ε) CONSISTENT : consistent_arrival_times arr_seq
j \in arrivals_at arr_seq (t1 + A)
by move : ARR => [t ARR]; rewrite subnKC //; feed (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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 arr_seq tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 arr_seq tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 arr_seq tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 arr_seq tsk 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 arr_seq tsk t1 (t1 + A + ε)
= task_workload_between arr_seq tsk t1 (t1 + A) + task_workload_between 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 arr_seq tsk t1 (t1 + A + ε) =
task_workload_between arr_seq tsk t1 (t1 + A) +
task_workload_between 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 arr_seq tsk t1 (t1 + A + ε) =
task_workload_between arr_seq tsk t1 (t1 + A) +
task_workload_between arr_seq tsk (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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 arr_seq tsk t1
(t1 + A + ε) =
task_workload_between arr_seq tsk t1 (t1 + A) +
task_workload_between arr_seq tsk
(t1 + A)
(t1 + A + ε)
task_workload_between arr_seq tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 arr_seq tsk t1 (t1 + A) +
task_workload_between arr_seq tsk (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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 arr_seq tsk (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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 arr_seq tsk t1 (t1 + A) +
(task_workload_between arr_seq tsk (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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 arr_seq tsk (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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival 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 :
cumulative_interference j t1 (t1 + x)
<= (task_rbf (A + ε) - task_cost tsk) + cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x)
cumulative_interference j t1 (t1 + x) <=
task_rbf (A + ε) - task_cost tsk +
cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched j t1 t2 A := job_arrival j - t1 : duration x : duration H_inside_busy_interval : t1 + x < t2 H_job_j_is_not_completed : ~~
completed_by sched j
(t1 + x)
cumulative_interference j t1 (t1 + x) <=
task_rbf (A + ε) - task_cost tsk +
cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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
cumulative_interference j t1 y <=
task_rbf (A + ε) - task_cost tsk +
cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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; rt_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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 + ε)
cumulative_interference j t1 y <=
task_rbf (A + ε) - task_cost tsk +
cumul_task_interference tsk t2 t1 y
apply leq_trans with (task_workload_between arr_seq tsk t1 (t1+A+ε) - job_cost j + cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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 + ε)
cumulative_interference j t1 y <=
task_workload_between arr_seq tsk t1 (t1 + A + ε) -
job_cost j + cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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 + ε)
cumulative_interference j t1 y <=
task_workload_between arr_seq tsk t1 (t1 + A + ε) -
job_cost j + cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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 arr_seq tsk t1 (t1 + A + ε) -
job_cost j + cumul_task_interference tsk t2 t1 y <=
task_rbf (A + ε) - task_cost tsk +
cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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 arr_seq tsk t1 (t1 + A + ε) -
job_cost j + cumul_task_interference tsk t2 t1 y <=
task_rbf (A + ε) - task_cost tsk +
cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 sched 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 arr_seq tsk t1 (t1 + A + ε) -
job_cost j <= task_rbf (A + ε) - task_cost tsk
by 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : 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 : duration 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : 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 : duration 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]; move => 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : 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 : duration 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : 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 : duration 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : 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 : duration 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : 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 : duration 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : 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 : duration 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : 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 : duration 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : 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 : duration 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : 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 : duration 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : 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 : duration 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; rt_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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : 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 : duration 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : 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 : duration 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched L : duration H_busy_interval_exists : busy_intervals_are_bounded_by
arr_seq sched tsk L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : 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 : duration 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 :
task_response_time_bound arr_seq sched 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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
task_response_time_bound arr_seq sched 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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
task_response_time_bound arr_seq sched tsk R
move => 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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_ideal 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 (ideal.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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 (ideal.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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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
(fun (tsk : Task) (A : nat) (R : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A R)
(relative_arrival_time_of_job_is_A 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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
(fun (tsk : Task) (A : nat) (R : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A R)
(relative_arrival_time_of_job_is_A sched)
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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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
(fun (tsk : Task) (A : nat) (R : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A R)
(relative_arrival_time_of_job_is_A sched)
move => t1 t2 R j ARR TSK BUSY NEQ 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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 ARR : arrives_in arr_seq j TSK : job_of_task tsk j BUSY : busy_interval sched j t1 t2 NEQ : t1 + R < t2 COMPL : ~~ completed_by sched j (t1 + R)
forall X : nat,
relative_arrival_time_of_job_is_A sched j X ->
cumulative_interference j t1 (t1 + R) <=
task_rbf (X + ε) - task_cost tsk +
task_interference_bound_function tsk X 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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 ARR : arrives_in arr_seq j TSK : job_of_task tsk j BUSY : busy_interval sched j t1 t2 NEQ : t1 + R < t2 COMPL : ~~ completed_by sched j (t1 + R) ZERO : job_cost j = 0
forall X : nat,
relative_arrival_time_of_job_is_A sched j X ->
cumulative_interference j t1 (t1 + R) <=
task_rbf (X + ε) - task_cost tsk +
task_interference_bound_function tsk X 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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 ARR : arrives_in arr_seq j TSK : job_of_task tsk j BUSY : busy_interval sched j t1 t2 NEQ : t1 + R < t2 COMPL : ~~ completed_by sched j (t1 + R) ZERO : job_cost j = 0
forall X : nat,
relative_arrival_time_of_job_is_A sched j X ->
cumulative_interference j t1 (t1 + R) <=
task_rbf (X + ε) - task_cost tsk +
task_interference_bound_function tsk X R
exfalso ; 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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 ARR : arrives_in arr_seq j TSK : job_of_task tsk j BUSY : busy_interval sched j t1 t2 NEQ : 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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 ARR : arrives_in arr_seq j TSK : job_of_task tsk j BUSY : busy_interval sched j t1 t2 NEQ : t1 + R < t2 COMPL : ~~ completed_by sched j (t1 + R) POS : 0 < job_cost j
forall X : nat,
relative_arrival_time_of_job_is_A sched j X ->
cumulative_interference j t1 (t1 + R) <=
task_rbf (X + ε) - task_cost tsk +
task_interference_bound_function tsk X R
move => A LE; specialize (LE _ _ BUSY).Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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 ARR : arrives_in arr_seq j TSK : job_of_task tsk j BUSY : busy_interval sched j t1 t2 NEQ : t1 + R < t2 COMPL : ~~ completed_by sched j (t1 + R) POS : 0 < job_cost jA : nat LE : job_arrival j = t1 + A
cumulative_interference j t1 (t1 + R) <=
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A R
apply leq_trans with (task_rbf (A + ε) - task_cost tsk + cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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 ARR : arrives_in arr_seq j TSK : job_of_task tsk j BUSY : busy_interval sched j t1 t2 NEQ : t1 + R < t2 COMPL : ~~ completed_by sched j (t1 + R) POS : 0 < job_cost jA : nat LE : job_arrival j = t1 + A
cumulative_interference j t1 (t1 + R) <=
task_rbf (A + ε) - task_cost tsk +
cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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 ARR : arrives_in arr_seq j TSK : job_of_task tsk j BUSY : busy_interval sched j t1 t2 NEQ : t1 + R < t2 COMPL : ~~ completed_by sched j (t1 + R) POS : 0 < job_cost jA : nat LE : job_arrival j = t1 + A
cumulative_interference j t1 (t1 + R) <=
task_rbf (A + ε) - task_cost tsk +
cumul_task_interference tsk t2 t1 (t1 + R)
rewrite -/cumulative_interference.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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 ARR : arrives_in arr_seq j TSK : job_of_task tsk j BUSY : busy_interval sched j t1 t2 NEQ : t1 + R < t2 COMPL : ~~ completed_by sched j (t1 + R) POS : 0 < job_cost jA : nat LE : job_arrival j = t1 + A
cumulative_interference j t1 (t1 + R) <=
task_rbf (A + ε) - task_cost tsk +
cumul_task_interference tsk t2 t1 (t1 + R)
eapply leq_trans; first 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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 ARR : arrives_in arr_seq j TSK : job_of_task tsk j BUSY : busy_interval sched j t1 t2 NEQ : t1 + R < t2 COMPL : ~~ completed_by sched j (t1 + R) POS : 0 < job_cost jA : nat LE : job_arrival j = t1 + A
task_rbf (job_arrival j - t1 + ε) - task_cost tsk +
cumul_task_interference tsk t2 t1 (t1 + R) <=
task_rbf (A + ε) - task_cost tsk +
cumul_task_interference tsk t2 t1 (t1 + R)
by rewrite LE; replace (t1 + A - t1) with A by lia .Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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 ARR : arrives_in arr_seq j TSK : job_of_task tsk j BUSY : busy_interval sched j t1 t2 NEQ : t1 + R < t2 COMPL : ~~ completed_by sched j (t1 + R) POS : 0 < job_cost jA : nat LE : job_arrival j = t1 + A
task_rbf (A + ε) - task_cost tsk +
cumul_task_interference tsk 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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 ARR : arrives_in arr_seq j TSK : job_of_task tsk j BUSY : busy_interval sched j t1 t2 NEQ : t1 + R < t2 COMPL : ~~ completed_by sched j (t1 + R) POS : 0 < job_cost jA : nat LE : job_arrival j = t1 + A
task_rbf (A + ε) - task_cost tsk +
cumul_task_interference tsk t2 t1 (t1 + R) <=
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A R
rewrite leq_add2l; eapply leq_trans.Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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 ARR : arrives_in arr_seq j TSK : job_of_task tsk j BUSY : busy_interval sched j t1 t2 NEQ : t1 + R < t2 COMPL : ~~ completed_by sched j (t1 + R) POS : 0 < job_cost jA : nat LE : job_arrival j = t1 + A
cumul_task_interference tsk t2 t1 (t1 + R) <= ?n
- Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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 ARR : arrives_in arr_seq j TSK : job_of_task tsk j BUSY : busy_interval sched j t1 t2 NEQ : t1 + R < t2 COMPL : ~~ completed_by sched j (t1 + R) POS : 0 < job_cost jA : nat LE : job_arrival j = t1 + A
cumul_task_interference tsk t2 t1 (t1 + R) <= ?n
by apply H_task_interference_is_bounded; 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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 ARR : arrives_in arr_seq j TSK : job_of_task tsk j BUSY : busy_interval sched j t1 t2 NEQ : t1 + R < t2 COMPL : ~~ completed_by sched j (t1 + R) POS : 0 < job_cost jA : nat LE : job_arrival j = t1 + A
task_interference_bound_function tsk
(job_arrival j - t1) R <=
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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_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 ARR : arrives_in arr_seq j TSK : job_of_task tsk j BUSY : busy_interval sched j t1 t2 NEQ : t1 + R < t2 COMPL : ~~ completed_by sched j (t1 + R) POS : 0 < job_cost jA : nat LE : job_arrival j = t1 + A
task_interference_bound_function tsk
(job_arrival j - t1) R <=
task_interference_bound_function tsk A R
by replace (job_arrival j - t1) with A by lia .
} Task : TaskType H : TaskCost Task H0 : TaskRunToCompletionThreshold Task Job : JobType H1 : JobTask Job Task H2 : JobArrival Job H3 : JobCost Job H4 : JobPreemptable Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence
sched arr_seq H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute
sched H_completed_jobs_dont_execute : completed_jobs_dont_execute
sched H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts H6 : Interference Job H7 : InterferingWorkload Job task_rbf := task_request_bound_function tsk : duration -> nat arrivals_between := arrival_sequence.arrivals_between
arr_seq : instant -> instant -> seq Job service_of_jobs_at := service_of_jobs.service_of_jobs_at
sched : pred Job ->
seq Job -> instant -> nat H_work_conserving : work_conserving arr_seq sched 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 L task_interference_bound_function : Task ->
duration ->
duration ->
duration H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
task_interference_bound_function
tsk A Δ: Task ->
duration -> duration -> nat is_in_search_space_seq := is_in_search_space tsk L
total_interference_bound : nat -> Prop R : duration 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 .