Checkpoint commit,initial timer merge design

3 files changed, 218 insertions, 16 deletions

diff --git a/litmus/event_group.c b/litmus/event_group.c
new file mode 100644
index 000000000000..11a690d5b2cd
--- /dev/null
+++ b/litmus/event_group.c
@@ -0,0 +1,198 @@
+#include <litmus/event_group.h>
+#include <litmus/trace.h>
+#include <linux/sched.h>
+
+/*
+ * Return event_queue slot for the given time.
+ */
+static unsigned int time2slot(lt_t time)
+{
+        return (unsigned int) time2quanta(time, FLOOR) % EVENT_QUEUE_SLOTS;
+}
+
+/*
+ * Executes events from an event_list in priority order.
+ * Events can requeue themselves when they are called.
+ */
+static enum hrtimer_restart on_timer(struct hrtimer *timer)
+{
+        unsigned long flags;
+        event_list_t *el;
+        rt_event_t *e;
+        struct list_head *pos, *safe, list;
+
+        el = container_of(timer, event_list_t, timer);
+
+        raw_spin_lock_irqsave(&el->group->queue_lock, flags);
+        list_del_init(&el->list);
+        raw_spin_unlock_irqrestore(&el->group->queue_lock, flags);
+
+        /* Empty event list so this event can be requeued */
+        list_del_init(&el->events, list);
+
+        /* Fire events */
+        list_for_each_safe(pos, safe, &el->events) {
+                e = list_entry(pos, rt_event_t, list);
+                TRACE("Dequeueing event with prio %d\n", e->prio);
+                list_del_init(pos);
+                e->fire(e->data);
+        }
+}
+
+/*
+ * Insert event in event-list, respecting priority order.
+ */
+void insert_event(event_list_t *el, rt_event_t *e)
+{
+        struct list_head *pos;
+        event_list_t *queued;
+        list_for_each_prev(pos, &el->events) {
+                queued = list_entry(pos, event_list_t, list);
+                if (e->prio < queued->prio) {
+                        __list_add(&e->list, pos, pos->next);
+                        return;
+                }
+        }
+        list_add(&e->list, &el->events);
+}
+
+/*
+ * Return event_list for the given event and time. If no event_list
+ * is being used yet and use_event_heap is 1, will create the list
+ * and return it. Otherwise it will return NULL.
+ */
+static event_list_t* get_event_list(event_group_t *group,
+                                    rt_event_t *e,
+                                    lt_t fire,
+                                    int use_event_heap)
+{
+        struct list_head* pos;
+        event_list_t *el = NULL, *tmp;
+        unsigned int slot = time2slot(release_time);
+
+        /* initialize pos for the case that the list is empty */
+        pos = group->event_queue[slot].next;
+        list_for_each(pos, &group->event_queue[slot]) {
+                tmp = list_entry(pos, event_list_t, list);
+                if (lt_after_eq(fire, tmp->fire_time) &&
+                    lt_before(tmp->fire_time, fire)) {
+                        /* perfect match -- this happens on hyperperiod
+                         * boundaries
+                         */
+                        el = tmp;
+                        break;
+                } else if (lt_before(fire, tmp->fire_time)) {
+                        /* we need to insert a new node since rh is
+                         * already in the future
+                         */
+                        break;
+                }
+        }
+        if (!el && use_event_heap) {
+                /* use pre-allocated release heap */
+                tmp = e->event_list;
+                tmp->fire_time = fire;
+                tmp->group = group;
+                /* add to queue */
+                list_add(&tmp->list, pos->prev);
+                el = tmp;
+        }
+        return el;
+}
+
+/*
+ * Prepare a release heap for a new set of events.
+ */
+static void reinit_release_heap(rt_event_t *e)
+{
+        event_list_t *el = e->event_list;
+        BUG_ON(hrtimer_cancel(&el->timer));
+        INIT_LIST_HEAD(&el->events);
+        atomic_set(&el->info.state, HRTIMER_START_ON_INACTIVE);
+}
+
+/**
+ * add_event() - Add timer to event group.
+ */
+void add_event(event_group_t *group, rt_event_t *e, lt_t fire)
+{
+        event_list_t *el;
+
+        TRACE("Adding event with prio %d @ %llu\n", event->prio, fire);
+
+        raw_spin_lock(&group->queue_lock);
+        el = get_event_list(group, e, fire, 0);
+        if (!el) {
+                /* Use our own, but drop lock first */
+                raw_spin_unlock(&group->queue_lock);
+                reinit_event_list(e);
+                raw_spin_lock(&group->queue_lock);
+                el = get_event_list(group, e, fire, 1);
+        }
+
+        /* Add event to sorted list */
+        insert_event(el, e);
+        raw_spin_unlock(&group->queue_lock);
+
+        /* Arm timer if we are the owner */
+        if (el == e->event_list) {
+                TRACE("Arming timer for %llu\n", fire);
+                if (group->cpu == smp_processor_id()) {
+                        __hrtimer_start_range_ns(&el->timer,
+                                                 ns_to_ktime(el->fire_time),
+                                                 0, HRTIMER_MODE_ABS_PINNED, 0);
+                } else {
+                        hrtimer_start_on(group->cpu, &el->info,
+                                         &el->timer, ns_to_ktime(el->fire_time),
+                                         HRTIMER_MODE_ABS_PINNED);
+                }
+        } else {
+                TRACE("Not my timer @%llu", fire);
+        }
+}
+
+/**
+ * cancel_event() - Remove event from the group.
+ */
+void cancel_event(event_group_t *group, rt_event_t *e)
+{
+        raw_spin_lock(&group->queue_lock);
+        list_del_init(&e->list);
+        raw_spin_unlock(&group->queue_lock);
+}
+
+/**
+ * init_event_group() - Prepare group for events.
+ */
+void init_event_group(event_group_t *group, lt_t res)
+{
+        int i;
+        group->res = res;
+        group->cpu = cpu;
+
+        INIT_LIST_HEAD(group->tobe_queued);
+        for (i = 0; i < EVENT_QUEUE_SLOTS; i++) {
+                INIT_LIST_HEAD(&group->event_queue[i]);
+        }
+
+        raw_spin_lock_init(&group->queue_lock);
+        raw_spin_lock_init(&group->tobe_lock);
+}
+
+struct kmem_cache *event_list_cache;
+event_list_t* event_list_alloc(int gfp_flags)
+{
+        event_list_t *el = kmem_cache_alloc(event_list_cache, gfp_flags);
+        if (el) {
+                hrtimer_init(&el->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
+                INIT_LIST_HEAD(&el->list);
+                el->timer.function = on_timer;
+        }
+        return el;
+}
+
+void event_list_free(event_list_t *el)
+{
+        hrtimer_cancel(&el->timer);
+        kmem_cache_free(event_list_cache, el);
+}
diff --git a/litmus/litmus.c b/litmus/litmus.c
index 89fb4e9aff8c..0e7cc753d8f2 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -37,8 +37,9 @@ atomic_t __log_seq_no = ATOMIC_INIT(0);
 atomic_t release_master_cpu = ATOMIC_INIT(NO_CPU);
 #endif
 
-static struct kmem_cache * bheap_node_cache;
-extern struct kmem_cache * release_heap_cache;
+static struct kmem_cache *bheap_node_cache;
+extern struct kmem_cache *release_heap_cache;
+extern struct kmem_cache *event_list_cache;
 
 struct bheap_node* bheap_node_alloc(int gfp_flags)
 {
@@ -610,8 +611,9 @@ static int __init _init_litmus(void)
 
         register_sched_plugin(&linux_sched_plugin);
 
-        bheap_node_cache    = KMEM_CACHE(bheap_node, SLAB_PANIC);
+        bheap_node_cache   = KMEM_CACHE(bheap_node, SLAB_PANIC);
         release_heap_cache = KMEM_CACHE(release_heap, SLAB_PANIC);
+        event_list_cache   = KMEM_CACHE(event_list, SLAB_PANIC);
 
 #ifdef CONFIG_MAGIC_SYSRQ
         /* offer some debugging help */
@@ -631,6 +633,7 @@ static void _exit_litmus(void)
         exit_litmus_proc();
         kmem_cache_destroy(bheap_node_cache);
         kmem_cache_destroy(release_heap_cache);
+        kmem_cache_destroy(event_list_cache);
 }
 
 module_init(_init_litmus);
diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 596742aa5583..9eae2b716a01 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -768,7 +768,6 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
                                 raw_spin_unlock(dom->lock);
                                 update_crit_levels(entry);
                                 raw_spin_lock(&entry->lock);
-                                continue;
                         }
                 }
                 raw_spin_unlock(dom->lock);
@@ -804,18 +803,6 @@ static long mc_activate_plugin(void)
  * Initialization
  * ************************************************************************** */
 
-static struct sched_plugin mc_plugin __cacheline_aligned_in_smp = {
-        .plugin_name            = "MC",
-        .task_new               = mc_task_new,
-        .complete_job           = complete_job,
-        .task_exit              = mc_task_exit,
-        .schedule               = mc_schedule,
-        .task_wake_up           = mc_task_wake_up,
-        .task_block             = mc_task_block,
-        .admit_task             = mc_admit_task,
-        .activate_plugin        = mc_activate_plugin,
-};
-
 /* Initialize values here so that they are allocated with the module
  * and destroyed when the module is unloaded.
  */
@@ -832,6 +819,20 @@ static rt_domain_t _mc_crit_c_rt;
 struct bheap _mc_heap_c;
 struct bheap_node _mc_nodes_c[NR_CPUS];
 
+release_at)_
+
+static struct sched_plugin mc_plugin __cacheline_aligned_in_smp = {
+        .plugin_name            = "MC",
+        .task_new               = mc_task_new,
+        .complete_job           = complete_job,
+        .task_exit              = mc_task_exit,
+        .schedule               = mc_schedule,
+        .task_wake_up           = mc_task_wake_up,
+        .task_block             = mc_task_block,
+        .admit_task             = mc_admit_task,
+        .activate_plugin        = mc_activate_plugin,
+};
+
 static void init_crit_entry(crit_entry_t *ce, enum crit_level level,
                             domain_data_t *dom_data,
                             struct bheap_node *node)