Library rt.restructuring.model.arrival.arrival_curves

From rt.util Require Import all.
From rt.restructuring.behavior Require Export arrival_sequence.
From rt.restructuring.model Require Export task_arrivals.

(* In this section, we define the notion of arrival curves, which
   can be used to reason about the frequency of job arrivals. *)

Section ArrivalCurves.

  Context {Task: TaskType}.
  Context {Job: JobType}.
  Context `{JobTask Job Task}.

  (* Consider any job arrival sequence. *)
  Variable arr_seq: arrival_sequence Job.

  (* First, we define what constitutes an arrival bound for a task. *)
  Section ArrivalCurves.

    (* We say that num_arrivals is a valid arrival curve for task tsk iff *)
    (* [num_arrivals] is a monotonic function that equals 0 for the empty *)
    (* interval delta = 0. *)
    Definition valid_arrival_curve (tsk: Task) (num_arrivals: duration nat) :=
      num_arrivals 0 = 0
      monotone num_arrivals leq.

    (* We say that max_arrivals is an upper arrival bound for tsk iff, for any interval [t1, t2),
     [max_arrivals (t2 - t1)] bounds the number of jobs of tsk that arrive in that interval. *)

    Definition respects_max_arrivals (tsk: Task) (max_arrivals: duration nat) :=
       (t1 t2: instant),
        t1 t2
        size (task_arrivals_between arr_seq tsk t1 t2) max_arrivals (t2 - t1).

    (* We define in the same way lower arrival bounds *)
    Definition respects_min_arrivals (tsk: Task) (min_arrivals: duration nat) :=
       (t1 t2: instant),
        t1 t2
        min_arrivals (t2 - t1) size (task_arrivals_between arr_seq tsk t1 t2).

  End ArrivalCurves.

  Section SeparationBound.

    (* Then, we say that min_separation is a lower separation bound iff, for any number of jobs
       of tsk, min_separation lower-bounds the minimum interval length in which that number
       of jobs can be spawned. *)

    Definition respects_min_separation tsk (min_separation: nat duration) :=
       t1 t2,
          t1 t2
          min_separation (size (task_arrivals_between arr_seq tsk t1 t2)) t2 - t1.

    (* We define in the same way upper separation bounds *)
    Definition respects_max_separation tsk (max_separation: nat duration):=
       t1 t2,
        t1 t2
        t2 - t1 max_separation (size (task_arrivals_between arr_seq tsk t1 t2)).

  End SeparationBound.

End ArrivalCurves.

(* We define generic classes for arrival curves  *)
Class MaxArrivals (Task: TaskType) := max_arrivals: Task duration nat.

Class MinArrivals (Task: TaskType) := min_arrivals: Task duration nat.

Class MaxSeparation (Task: TaskType) := max_separation: Task nat duration.

Class MinSeparation (Task: TaskType) := min_separation: Task nat duration.

Section ArrivalCurvesModel.

  Context {Task: TaskType} {Job: JobType}.
  Context `{JobTask Job Task}.

  Context `{MaxArrivals Task} `{MinArrivals Task} `{MaxSeparation Task} `{MinSeparation Task}.

  Variable ts: seq Task.

  (* We say that arrivals is a valid arrival curve for a taskset if it is valid for any task
     in the taskset *)

  Definition valid_taskset_arrival_curve (arrivals : Task duration nat) :=
     tsk,
      tsk \in ts
      valid_arrival_curve tsk (arrivals tsk).

  Variable arr_seq: arrival_sequence Job.

  (* We say that max_arrivals is an arrival bound for taskset ts *)
  (* iff max_arrival is an arrival bound for any task from ts. *)
  Definition taskset_respects_max_arrivals :=
     (tsk: Task), tsk \in ts respects_max_arrivals arr_seq tsk (max_arrivals tsk).

  Definition taskset_respects_min_arrivals :=
     (tsk: Task), tsk \in ts respects_min_arrivals arr_seq tsk (min_arrivals tsk).

  Definition taskset_respects_max_separation :=
     (tsk: Task), tsk \in ts respects_max_separation arr_seq tsk (max_separation tsk).

  Definition taskset_respects_min_separation :=
     (tsk: Task), tsk \in ts respects_min_separation arr_seq tsk (min_separation tsk).

End ArrivalCurvesModel.