Have a hard-coded component-wide forbidden zone working.

3 files changed, 54 insertions, 43 deletions

diff --git a/include/litmus/reservations/gedf_reservation.h b/include/litmus/reservations/gedf_reservation.h
index 927e83f4bc2e..d9694fa3ac64 100644
--- a/include/litmus/reservations/gedf_reservation.h
+++ b/include/litmus/reservations/gedf_reservation.h
@@ -69,7 +69,8 @@ struct gedf_reservation_environment {
 
 #ifdef CONFIG_LITMUS_LOCKING
         /* reservations sleeping due to forbidden zones */
-        wait_queue_head_t fz_waiters;
+        int num_waiter_queues;
+        wait_queue_head_t* fz_waiters;
 #endif
 };
 
diff --git a/include/litmus/reservations/table_driven_ext_reservation.h b/include/litmus/reservations/table_driven_ext_reservation.h
index 36d20c91a8dc..c906ceb785bb 100644
--- a/include/litmus/reservations/table_driven_ext_reservation.h
+++ b/include/litmus/reservations/table_driven_ext_reservation.h
@@ -5,14 +5,14 @@
 
 /* ************************************************************************** */
 struct mtd_reservation {
-        struct reservation res[4];
+        struct reservation res[NR_CPUS];
         lt_t major_cycle;
-        unsigned int interval_index[4];
-        unsigned int num_intervals[4];
-        struct lt_interval* intervals[4];
+        unsigned int interval_index[NR_CPUS];
+        unsigned int num_intervals[NR_CPUS];
+        struct lt_interval* intervals[NR_CPUS];
 
-        struct lt_interval cur_interval[4];
-        lt_t major_cycle_start[4];
+        struct lt_interval cur_interval[NR_CPUS];
+        lt_t major_cycle_start[NR_CPUS];
 };
 
 long mtd_res_install_table(
diff --git a/litmus/reservations/gedf_reservation.c b/litmus/reservations/gedf_reservation.c
index 0d02e31bac89..b037f63ed119 100644
--- a/litmus/reservations/gedf_reservation.c
+++ b/litmus/reservations/gedf_reservation.c
@@ -555,6 +555,10 @@ static void gedf_env_resume(
         unsigned long flags;
         // Needs to be volatile or it may be optimized to gedf_env->num_cpus
         volatile int tmp_cpus;
+        // For waking up forbidden-zone waiters
+        int i;
+        struct task_struct *next;
+        struct reservation *next_res;
 
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
         entry = &gedf_env->cpu_entries[cpu];
@@ -584,26 +588,18 @@ static void gedf_env_resume(
                 domain_resume_releases(&gedf_env->domain);
 
 #ifdef CONFIG_LITMUS_LOCKING
-        // Only the first cpu to resume should wake up forbidden-zone waiters
-        if (!tmp_cpus) {
-                // if (gedf_env->env.res->id == 1)
-                //      printk("[%u] About to check for waiters.\n", gedf_env->env.res->id);
-
-                // Wake up any forbidden-zone waiters
-                spin_lock_irqsave(&gedf_env->fz_waiters.lock, flags);
-
-                struct task_struct *next;
-                while ((next) = __waitqueue_remove_first(&gedf_env->fz_waiters)) {
-                        printk("[%u] Waking up process %d, state=%d.\n", gedf_env->env.res->id, next->pid, next->state);
-
-                        /* wake up next by re-adding it to the gedf env */
-                        struct reservation *next_res = (struct reservation *) tsk_rt(next)->plugin_state;
-                        gedf_env_add_res(env, next_res, cpu);
-
-                        printk("[%u] Woke up %d.\n", gedf_env->env.res->id, next->pid);
+        // Wake up any forbidden-zone waiters
+        for (i = 0; i < gedf_env->num_waiter_queues; i++) {
+                if (i == cpu)
+                        continue;
+
+                spin_lock_irqsave(&gedf_env->fz_waiters[i].lock, flags);
+                while ( (next = __waitqueue_remove_first(&gedf_env->fz_waiters[i])) ) {
+                        next_res = (struct reservation *) tsk_rt(next)->plugin_state;
+                        wake_up_process(next);
                 }
 
-                spin_unlock_irqrestore(&gedf_env->fz_waiters.lock, flags);
+                spin_unlock_irqrestore(&gedf_env->fz_waiters[i].lock, flags);
         }
 #endif
 }
@@ -965,15 +961,20 @@ static struct task_struct* omlp_find_hp_waiter(struct omlp_semaphore *sem,
 
 int gedf_env_omlp_lock(struct litmus_lock* l)
 {
+        // The task and the semaphore
         struct task_struct* t = current;
         struct omlp_semaphore *sem = omlp_from_lock(l);
         prio_wait_queue_t wait;
-        wait_queue_t fz_wait;
         unsigned long flags;
+        // Various scheduler entities
         struct reservation *t_res, *o_res;
         struct gedf_reservation *gedf_res;
         struct gedf_reservation_environment *gedf_env;
-        lt_t remaining_component_budget, fz_length;
+        // Forbidden zones
+        unsigned int cpu;
+        lt_t timeslice_end, remaining_component_budget, fz_length;
+        wait_queue_t fz_wait;
+        struct mtd_reservation *mtd_res;
 
         if (!is_realtime(t))
                 return -EPERM;
@@ -1039,39 +1040,36 @@ int gedf_env_omlp_lock(struct litmus_lock* l)
          * thus might not reflect the current remaining budget
          * for the component */
         gedf_env = container_of(t_res->par_env, struct gedf_reservation_environment, env);
-        spin_lock_irqsave(&gedf_env->fz_waiters.lock, flags);
+        spin_lock_irqsave(&gedf_env->fz_waiters[0].lock, flags);
+
+        cpu = smp_processor_id();
 
-        unsigned int cpu = smp_processor_id();
-        struct mtd_reservation *mtd_res = (struct mtd_reservation*)t_res->par_env->res;
-        lt_t timeslice_end = mtd_res->cur_interval[cpu].end + mtd_res->major_cycle_start[cpu];
+        spin_unlock_irqrestore(&gedf_env->fz_waiters[0].lock, flags);
+        spin_lock_irqsave(&gedf_env->fz_waiters[cpu].lock, flags);
+
+        mtd_res = (struct mtd_reservation*)t_res->par_env->res;
+        timeslice_end = mtd_res->cur_interval[cpu].end + mtd_res->major_cycle_start[cpu];
         remaining_component_budget = timeslice_end - litmus_clock();
 
         fz_length = 100 * 1000000LL; // for now, hard-coded at 100ms
         if (remaining_component_budget < fz_length) {
                 /* go on a wait queue to be woken up when the parent reservation
                 * is next scheduled */
-                printk("%d in the forbidden zone, going on wait queue (budget left: %llu)\n",
-                        t->pid, remaining_component_budget);
-
                 init_waitqueue_entry(&fz_wait, t);
                 set_task_state(t, TASK_UNINTERRUPTIBLE);
-                __add_wait_queue_tail_exclusive(&gedf_env->fz_waiters, &fz_wait);
+                __add_wait_queue_tail_exclusive(&gedf_env->fz_waiters[cpu], &fz_wait);
 
                 TS_LOCK_SUSPEND;
 
-                spin_unlock_irqrestore(&gedf_env->fz_waiters.lock, flags);
+                spin_unlock_irqrestore(&gedf_env->fz_waiters[cpu].lock, flags);
 
                 BUG_ON(!gedf_res->linked_on && !bheap_node_in_heap(t_res->heap_node));
 
-                schedule(); // calls gedf_env_remove_res()
+                schedule();
 
                 TS_LOCK_RESUME;
-
-                printk("%d awake!\n", t->pid);
         } else {
-                printk("%d is not in the FZ, budget remaining is %llu\n",
-                        t->pid, remaining_component_budget);
-                spin_unlock_irqrestore(&gedf_env->fz_waiters.lock, flags);
+                spin_unlock_irqrestore(&gedf_env->fz_waiters[cpu].lock, flags);
         }
 
         return 0;
@@ -1268,6 +1266,15 @@ long alloc_gedf_reservation_environment(
                 kfree(gedf_env);
                 return -ENOMEM;
         }
+#ifdef CONFIG_LITMUS_LOCKING
+        gedf_env->fz_waiters = kzalloc(sizeof(wait_queue_head_t)*total_cpus, GFP_ATOMIC);
+        if (!gedf_env->fz_waiters) {
+                kfree(gedf_env->cpu_entries);
+                kfree(gedf_env->cpu_node);
+                kfree(gedf_env);
+                return -ENOMEM;
+        }
+#endif
 
         /* set environment callback actions */
         gedf_env->env.ops = &gedf_env_ops;
@@ -1287,7 +1294,10 @@ long alloc_gedf_reservation_environment(
         rt_domain_init(&gedf_env->domain, edf_ready_order, NULL, gedf_env_release_jobs);
 
 #ifdef CONFIG_LITMUS_LOCKING
-        init_waitqueue_head(&gedf_env->fz_waiters);
+        gedf_env->num_waiter_queues = max_cpus;
+        for (i = 0; i < max_cpus; i++) {
+                init_waitqueue_head(&gedf_env->fz_waiters[i]);
+        }
 #endif
 
         *_env = gedf_env;