Library prosa.classic.analysis.uni.susp.dynamic.jitter.rta_by_reduction

Basic Setup & Setting

    Variable ts: seq Task.
    Hypothesis H_constrained_deadlines:
      constrained_deadline_model task_period task_deadline ts.

    Variable arr_seq: arrival_sequence Job.
    Hypothesis H_arrival_times_are_consistent:
      arrival_times_are_consistent job_arrival arr_seq.
    Hypothesis H_arrival_sequence_is_a_set: arrival_sequence_is_a_set arr_seq.

    Hypothesis H_sporadic_arrivals:
      sporadic_task_model task_period job_arrival job_task arr_seq.

    Hypothesis H_jobs_from_taskset:
      ∀ j, arrives_in arr_seq j → job_task j \in ts.

    Hypothesis H_job_deadlines_equal_task_deadlines:
      ∀ j, arrives_in arr_seq j → job_deadline j = task_deadline (job_task j).

    Variable higher_eq_priority: FP_policy Task.
    Hypothesis H_priority_is_reflexive: FP_is_reflexive higher_eq_priority.
    Hypothesis H_priority_is_transitive: FP_is_transitive higher_eq_priority.
    Hypothesis H_priority_is_total: FP_is_total_over_task_set higher_eq_priority ts.
    Let job_higher_eq_priority := FP_to_JLDP job_task higher_eq_priority.

    Variable job_cost: Job → time.
    Variable task_cost: Task → time.

    Variable job_suspension_duration: job_suspension Job.
    Variable task_suspension_bound: Task → time.

    Hypothesis H_positive_costs:
      ∀ j, arrives_in arr_seq j → job_cost j > 0.

    Variable sched_susp: schedule Job.
    Hypothesis H_valid_schedule:
      valid_suspension_aware_schedule job_arrival arr_seq job_higher_eq_priority
                                      job_suspension_duration job_cost sched_susp.

Analysis Setup

    Variable tsk: Task.
    Hypothesis H_tsk_in_ts: tsk \in ts.

    Let other_hep_task tsk_other :=
      higher_eq_priority tsk_other tsk && (tsk_other != tsk ).
    Let task_response_time_in_sched_susp_bounded_by :=
      is_response_time_bound_of_task job_arrival job_cost job_task arr_seq sched_susp.
    Let job_response_time_in_sched_susp_bounded_by :=
      is_response_time_bound_of_job job_arrival job_cost sched_susp.
    Let completed_in_sched_susp_by := completed_by job_cost sched_susp.
    Let job_misses_no_deadline_in_sched_susp :=
      job_misses_no_deadline job_arrival job_cost job_deadline sched_susp.

    Variable R: Task → time.

    Hypothesis H_valid_response_time_bound_of_hp_tasks:
      ∀ tsk_hp,
        tsk_hp \in ts →
        other_hep_task tsk_hp →
        task_response_time_in_sched_susp_bounded_by tsk_hp (R tsk_hp).

    Definition actual_response_time (j_hp: Job) : time :=
      [pick -min r ≤ R (job_task j_hp) |
         job_response_time_in_sched_susp_bounded_by j_hp r ].

    Variable j: Job.
    Hypothesis H_j_arrives: arrives_in arr_seq j.
    Hypothesis H_job_of_tsk: job_task j = tsk.

    Hypothesis H_no_deadline_misses_for_previous_jobs:
      ∀ j0,
        arrives_in arr_seq j0 →
        job_arrival j0 < job_arrival j →
        job_task j0 = job_task j →
        job_misses_no_deadline_in_sched_susp j0.

Instantiation of the Reduction

    Let inflated_task_cost := ts_gen.inflated_task_cost task_cost task_suspension_bound tsk.
    Let task_jitter := ts_gen.task_jitter task_cost higher_eq_priority tsk.

    Let sched_jitter := reduction.sched_jitter job_arrival job_task arr_seq higher_eq_priority
                        job_cost job_suspension_duration j actual_response_time.

    Let inflated_job_cost := reduction.inflated_job_cost job_cost job_suspension_duration j.
    Let job_jitter := reduction.job_jitter job_arrival job_task higher_eq_priority job_cost j
                                           actual_response_time.

    Let job_response_time_in_sched_jitter_bounded_by :=
      is_response_time_bound_of_job job_arrival inflated_job_cost sched_jitter.

Central Hypothesis

Hypothesis H_valid_response_time_bound_in_sched_jitter:
job_response_time_in_sched_jitter_bounded_by j (R tsk).

Main Claim

    Theorem valid_response_time_bound_in_sched_susp:
      job_response_time_in_sched_susp_bounded_by j (R tsk).
    Proof.
      rename H_priority_is_reflexive into REFL, H_priority_is_transitive into TRANS,
             H_priority_is_total into TOT, H_jobs_from_taskset into FROM,
             H_valid_response_time_bound_of_hp_tasks into RESPhp,
             H_valid_response_time_bound_in_sched_jitter into RESPj.
      rewrite -H_job_of_tsk /job_response_time_in_sched_susp_bounded_by.
      try ( apply reduction_serv.jitter_reduction_job_j_completes_no_later with (job_task0 := job_task)
        (ts0 := ts) (arr_seq0 := arr_seq) (higher_eq_priority0 := higher_eq_priority)
        (task_period0 := task_period) (task_deadline0 := task_deadline) (job_deadline0 := job_deadline)
        (job_suspension_duration0 := job_suspension_duration) (R_hp := actual_response_time) ) ||
      apply reduction_serv.jitter_reduction_job_j_completes_no_later with (job_task := job_task)
        (ts := ts) (arr_seq := arr_seq) (higher_eq_priority := higher_eq_priority)
        (task_period := task_period) (task_deadline := task_deadline) (job_deadline := job_deadline)
        (job_suspension_duration := job_suspension_duration) (R_hp := actual_response_time);
        try (by done).
      {
        intros j_hp ARRhp OTHERhp.
        rewrite /actual_response_time.
        apply pick_min_holds; last by intros r _ RESP _.
        ∃ (R (job_task j_hp)); split; first by done.
        by apply RESPhp; try (by done); [by apply FROM | rewrite /other_hep_task -H_job_of_tsk].
      }
      {
        by rewrite /is_response_time_bound_of_job H_job_of_tsk; apply RESPj.
      }
    Qed.

  End ComparingResponseTimeBounds.

End RTAByReduction.