Reservations: fix time-tracking of table-driven reservations

Keep track of the current slot and major cycle explicitly to avoid
ambiguity when the budget charging is delayed into the next major
cycle due to a late interrupt or other sources of delay.

3 files changed, 46 insertions, 14 deletions

diff --git a/include/litmus/polling_reservations.h b/include/litmus/polling_reservations.h
index fa221817ad30..66c9b1e31f20 100644
--- a/include/litmus/polling_reservations.h
+++ b/include/litmus/polling_reservations.h
@@ -24,7 +24,10 @@ struct table_driven_reservation {
         unsigned int next_interval;
         unsigned int num_intervals;
         struct lt_interval *intervals;
-        struct lt_interval *cur_interval;
+
+        /* info about current scheduling slot */
+        struct lt_interval cur_interval;
+        lt_t major_cycle_start;
 };
 
 void table_driven_reservation_init(struct table_driven_reservation *tdres,
diff --git a/litmus/polling_reservations.c b/litmus/polling_reservations.c
index 2c481b46ba39..86a32068a3a8 100644
--- a/litmus/polling_reservations.c
+++ b/litmus/polling_reservations.c
@@ -318,7 +318,8 @@ static void td_client_arrives(
         switch (res->state) {
                 case RESERVATION_INACTIVE:
                         /* Figure out first replenishment time. */
-                        res->next_replenishment = td_next_major_cycle_start(tdres);
+                        tdres->major_cycle_start = td_next_major_cycle_start(tdres);
+                        res->next_replenishment  = tdres->major_cycle_start;
                         res->next_replenishment += tdres->intervals[0].start;
                         tdres->next_interval = 0;
 
@@ -368,11 +369,12 @@ static void td_client_departs(
 static lt_t td_time_remaining_until_end(struct table_driven_reservation *tdres)
 {
         lt_t now = tdres->res.env->current_time;
-        lt_t end = td_cur_major_cycle_start(tdres) + tdres->cur_interval->end;
-        TRACE("td_remaining(%u): start=%llu now=%llu end=%llu\n",
+        lt_t end = tdres->cur_interval.end;
+        TRACE("td_remaining(%u): start=%llu now=%llu end=%llu state=%d\n",
                 tdres->res.id,
-                td_cur_major_cycle_start(tdres) + tdres->cur_interval->start,
-                now, end);
+                tdres->cur_interval.start,
+                now, end,
+                tdres->res.state);
         if (now >=  end)
                 return 0;
         else
@@ -385,20 +387,36 @@ static void td_replenish(
         struct table_driven_reservation *tdres =
                 container_of(res, struct table_driven_reservation, res);
 
-        /* replenish budget */
-        tdres->cur_interval = tdres->intervals + tdres->next_interval;
+        TRACE("td_replenish(%u): expected_replenishment=%llu\n", res->id,
+                res->next_replenishment);
+
+        /* figure out current interval */
+        tdres->cur_interval.start = tdres->major_cycle_start +
+                tdres->intervals[tdres->next_interval].start;
+        tdres->cur_interval.end =  tdres->major_cycle_start +
+                tdres->intervals[tdres->next_interval].end;
+        TRACE("major_cycle_start=%llu => [%llu, %llu]\n",
+                tdres->major_cycle_start,
+                tdres->cur_interval.start,
+                tdres->cur_interval.end);
+
+        /* reset budget */
         res->cur_budget = td_time_remaining_until_end(tdres);
         res->budget_consumed = 0;
         TRACE("td_replenish(%u): %s budget=%llu\n", res->id,
                 res->cur_budget ? "" : "WARNING", res->cur_budget);
 
+        /* prepare next slot */
         tdres->next_interval = (tdres->next_interval + 1) % tdres->num_intervals;
-        if (tdres->next_interval)
-                res->next_replenishment = td_cur_major_cycle_start(tdres);
-        else
+        if (!tdres->next_interval)
                 /* wrap to next major cycle */
-                res->next_replenishment = td_next_major_cycle_start(tdres);
+                tdres->major_cycle_start += tdres->major_cycle;
+
+        /* determine next time this reservation becomes eligible to execute */
+        res->next_replenishment  = tdres->major_cycle_start;
         res->next_replenishment += tdres->intervals[tdres->next_interval].start;
+        TRACE("td_replenish(%u): next_replenishment=%llu\n", res->id,
+                res->next_replenishment);
 
 
         switch (res->state) {
@@ -433,6 +451,9 @@ static void td_drain_budget(
         /* Table-driven scheduling: instead of tracking the budget, we compute
          * how much time is left in this allocation interval. */
 
+        /* sanity check: we should never try to drain from future slots */
+        BUG_ON(tdres->cur_interval.start > res->env->current_time);
+
         switch (res->state) {
                 case RESERVATION_DEPLETED:
                 case RESERVATION_INACTIVE:
@@ -447,7 +468,12 @@ static void td_drain_budget(
                         if (!res->cur_budget) {
                                 res->env->change_state(res->env, res,
                                         RESERVATION_DEPLETED);
-                        } /* else: stay in current state */
+                        } else {
+                                /* sanity check budget calculation */
+                                BUG_ON(res->env->current_time >= tdres->cur_interval.end);
+                                BUG_ON(res->env->current_time < tdres->cur_interval.start);
+                        }
+
                         break;
         }
 }
@@ -515,7 +541,8 @@ void table_driven_reservation_init(
         reservation_init(&tdres->res);
         tdres->major_cycle = major_cycle;
         tdres->intervals = intervals;
-        tdres->cur_interval = intervals;
+        tdres->cur_interval.start = 0;
+        tdres->cur_interval.end   = 0;
         tdres->num_intervals = num_intervals;
         tdres->res.ops = &td_ops;
 }
diff --git a/litmus/reservation.c b/litmus/reservation.c
index 447fc5b1be23..f79689823be7 100644
--- a/litmus/reservation.c
+++ b/litmus/reservation.c
@@ -206,6 +206,7 @@ static void sup_charge_budget(
                         /* stop at the first ACTIVE reservation */
                         break;
         }
+        TRACE("finished charging budgets\n");
 }
 
 static void sup_replenish_budgets(struct sup_reservation_environment* sup_env)
@@ -222,6 +223,7 @@ static void sup_replenish_budgets(struct sup_reservation_environment* sup_env)
                         break;
                 }
         }
+        TRACE("finished replenishing budgets\n");
 
         /* request a scheduler update at the next replenishment instant */
         res = list_first_entry_or_null(&sup_env->depleted_reservations,