Refactor binomial heap names: heap -> bheap

- Binomial heap "heap" names conflicted with priority heap
  of cgroup in kernel
- This patch change binomial heap "heap" names in "bheap"

6 files changed, 110 insertions, 110 deletions

diff --git a/litmus/Makefile b/litmus/Makefile
index b15e65ee7f37..70c9684c3b98 100644
--- a/litmus/Makefile
+++ b/litmus/Makefile
@@ -10,7 +10,7 @@ obj-y     = sched_plugin.o litmus.o \
             fdso.o \
             srp.o \
             fmlp.o \
-            heap.o \
+            bheap.o \
             sched_gsn_edf.o
 
 obj-$(CONFIG_FEATHER_TRACE) += ft_event.o ftdev.o
diff --git a/litmus/heap.c b/litmus/bheap.c
index 112d14da46c3..528af97f18a6 100644
--- a/litmus/heap.c
+++ b/litmus/bheap.c
@@ -1,15 +1,15 @@
 #include "linux/kernel.h"
-#include "litmus/heap.h"
+#include "litmus/bheap.h"
 
-void heap_init(struct heap* heap)
+void bheap_init(struct bheap* heap)
 {
         heap->head = NULL;
         heap->min  = NULL;
 }
 
-void heap_node_init(struct heap_node** _h, void* value)
+void bheap_node_init(struct bheap_node** _h, void* value)
 {
-        struct heap_node* h = *_h;
+        struct bheap_node* h = *_h;
         h->parent = NULL;
         h->next   = NULL;
         h->child  = NULL;
@@ -20,8 +20,8 @@ void heap_node_init(struct heap_node** _h, void* value)
 
 
 /* make child a subtree of root */
-static void __heap_link(struct heap_node* root,
-                        struct heap_node* child)
+static void __bheap_link(struct bheap_node* root,
+                        struct bheap_node* child)
 {
         child->parent = root;
         child->next   = root->child;
@@ -30,11 +30,11 @@ static void __heap_link(struct heap_node* root,
 }
 
 /* merge root lists */
-static  struct heap_node* __heap_merge(struct heap_node* a,
-                                             struct heap_node* b)
+static  struct bheap_node* __bheap_merge(struct bheap_node* a,
+                                             struct bheap_node* b)
 {
-        struct heap_node* head = NULL;
-        struct heap_node** pos = &head;
+        struct bheap_node* head = NULL;
+        struct bheap_node** pos = &head;
 
         while (a && b) {
                 if (a->degree < b->degree) {
@@ -54,10 +54,10 @@ static  struct heap_node* __heap_merge(struct heap_node* a,
 }
 
 /* reverse a linked list of nodes. also clears parent pointer */
-static  struct heap_node* __heap_reverse(struct heap_node* h)
+static  struct bheap_node* __bheap_reverse(struct bheap_node* h)
 {
-        struct heap_node* tail = NULL;
-        struct heap_node* next;
+        struct bheap_node* tail = NULL;
+        struct bheap_node* next;
 
         if (!h)
                 return h;
@@ -74,10 +74,10 @@ static  struct heap_node* __heap_reverse(struct heap_node* h)
         return h;
 }
 
-static  void __heap_min(heap_prio_t higher_prio, struct heap* heap,
-                              struct heap_node** prev, struct heap_node** node)
+static  void __bheap_min(bheap_prio_t higher_prio, struct bheap* heap,
+                              struct bheap_node** prev, struct bheap_node** node)
 {
-        struct heap_node *_prev, *cur;
+        struct bheap_node *_prev, *cur;
         *prev = NULL;
 
         if (!heap->head) {
@@ -98,11 +98,11 @@ static  void __heap_min(heap_prio_t higher_prio, struct heap* heap,
         }
 }
 
-static  void __heap_union(heap_prio_t higher_prio, struct heap* heap,
-                                struct heap_node* h2)
+static  void __bheap_union(bheap_prio_t higher_prio, struct bheap* heap,
+                                struct bheap_node* h2)
 {
-        struct heap_node* h1;
-        struct heap_node *prev, *x, *next;
+        struct bheap_node* h1;
+        struct bheap_node *prev, *x, *next;
         if (!h2)
                 return;
         h1 = heap->head;
@@ -110,7 +110,7 @@ static  void __heap_union(heap_prio_t higher_prio, struct heap* heap,
                 heap->head = h2;
                 return;
         }
-        h1 = __heap_merge(h1, h2);
+        h1 = __bheap_merge(h1, h2);
         prev = NULL;
         x    = h1;
         next = x->next;
@@ -123,14 +123,14 @@ static  void __heap_union(heap_prio_t higher_prio, struct heap* heap,
                 } else if (higher_prio(x, next)) {
                         /* x becomes the root of next */
                         x->next = next->next;
-                        __heap_link(x, next);
+                        __bheap_link(x, next);
                 } else {
                         /* next becomes the root of x */
                         if (prev)
                                 prev->next = next;
                         else
                                 h1 = next;
-                        __heap_link(next, x);
+                        __bheap_link(next, x);
                         x = next;
                 }
                 next = x->next;
@@ -138,26 +138,26 @@ static  void __heap_union(heap_prio_t higher_prio, struct heap* heap,
         heap->head = h1;
 }
 
-static struct heap_node* __heap_extract_min(heap_prio_t higher_prio,
-                                            struct heap* heap)
+static struct bheap_node* __bheap_extract_min(bheap_prio_t higher_prio,
+                                            struct bheap* heap)
 {
-        struct heap_node *prev, *node;
-        __heap_min(higher_prio, heap, &prev, &node);
+        struct bheap_node *prev, *node;
+        __bheap_min(higher_prio, heap, &prev, &node);
         if (!node)
                 return NULL;
         if (prev)
                 prev->next = node->next;
         else
                 heap->head = node->next;
-        __heap_union(higher_prio, heap, __heap_reverse(node->child));
+        __bheap_union(higher_prio, heap, __bheap_reverse(node->child));
         return node;
 }
 
 /* insert (and reinitialize) a node into the heap */
-void heap_insert(heap_prio_t higher_prio, struct heap* heap,
-                 struct heap_node* node)
+void bheap_insert(bheap_prio_t higher_prio, struct bheap* heap,
+                 struct bheap_node* node)
 {
-        struct heap_node *min;
+        struct bheap_node *min;
         node->child  = NULL;
         node->parent = NULL;
         node->next   = NULL;
@@ -169,48 +169,48 @@ void heap_insert(heap_prio_t higher_prio, struct heap* heap,
                 min->parent = NULL;
                 min->next   = NULL;
                 min->degree = 0;
-                __heap_union(higher_prio, heap, min);
+                __bheap_union(higher_prio, heap, min);
                 heap->min   = node;
         } else
-                __heap_union(higher_prio, heap, node);
+                __bheap_union(higher_prio, heap, node);
 }
 
-void heap_uncache_min(heap_prio_t higher_prio, struct heap* heap)
+void bheap_uncache_min(bheap_prio_t higher_prio, struct bheap* heap)
 {
-        struct heap_node* min;
+        struct bheap_node* min;
         if (heap->min) {
                 min = heap->min;
                 heap->min = NULL;
-                heap_insert(higher_prio, heap, min);
+                bheap_insert(higher_prio, heap, min);
         }
 }
 
 /* merge addition into target */
-void heap_union(heap_prio_t higher_prio,
-                struct heap* target, struct heap* addition)
+void bheap_union(bheap_prio_t higher_prio,
+                struct bheap* target, struct bheap* addition)
 {
         /* first insert any cached minima, if necessary */
-        heap_uncache_min(higher_prio, target);
-        heap_uncache_min(higher_prio, addition);
-        __heap_union(higher_prio, target, addition->head);
+        bheap_uncache_min(higher_prio, target);
+        bheap_uncache_min(higher_prio, addition);
+        __bheap_union(higher_prio, target, addition->head);
         /* this is a destructive merge */
         addition->head = NULL;
 }
 
-struct heap_node* heap_peek(heap_prio_t higher_prio,
-                            struct heap* heap)
+struct bheap_node* bheap_peek(bheap_prio_t higher_prio,
+                            struct bheap* heap)
 {
         if (!heap->min)
-                heap->min = __heap_extract_min(higher_prio, heap);
+                heap->min = __bheap_extract_min(higher_prio, heap);
         return heap->min;
 }
 
-struct heap_node* heap_take(heap_prio_t higher_prio,
-                            struct heap* heap)
+struct bheap_node* bheap_take(bheap_prio_t higher_prio,
+                            struct bheap* heap)
 {
-        struct heap_node *node;
+        struct bheap_node *node;
         if (!heap->min)
-                heap->min = __heap_extract_min(higher_prio, heap);
+                heap->min = __bheap_extract_min(higher_prio, heap);
         node = heap->min;
         heap->min = NULL;
         if (node)
@@ -218,10 +218,10 @@ struct heap_node* heap_take(heap_prio_t higher_prio,
         return node;
 }
 
-int heap_decrease(heap_prio_t higher_prio, struct heap_node* node)
+int bheap_decrease(bheap_prio_t higher_prio, struct bheap_node* node)
 {
-        struct heap_node  *parent;
-        struct heap_node** tmp_ref;
+        struct bheap_node  *parent;
+        struct bheap_node** tmp_ref;
         void* tmp;
 
         /* bubble up */
@@ -245,11 +245,11 @@ int heap_decrease(heap_prio_t higher_prio, struct heap_node* node)
         return parent != NULL;
 }
 
-void heap_delete(heap_prio_t higher_prio, struct heap* heap,
-                 struct heap_node* node)
+void bheap_delete(bheap_prio_t higher_prio, struct bheap* heap,
+                 struct bheap_node* node)
 {
-        struct heap_node *parent, *prev, *pos;
-        struct heap_node** tmp_ref;
+        struct bheap_node *parent, *prev, *pos;
+        struct bheap_node** tmp_ref;
         void* tmp;
 
         if (heap->min != node) {
@@ -283,32 +283,32 @@ void heap_delete(heap_prio_t higher_prio, struct heap* heap,
                         prev->next = node->next;
                 else
                         heap->head = node->next;
-                __heap_union(higher_prio, heap, __heap_reverse(node->child));
+                __bheap_union(higher_prio, heap, __bheap_reverse(node->child));
         } else
                 heap->min = NULL;
         node->degree = NOT_IN_HEAP;
 }
 
 /* allocate a heap node for value and insert into the heap */
-int heap_add(heap_prio_t higher_prio, struct heap* heap,
+int bheap_add(bheap_prio_t higher_prio, struct bheap* heap,
              void* value, int gfp_flags)
 {
-        struct heap_node* hn = heap_node_alloc(gfp_flags);
+        struct bheap_node* hn = bheap_node_alloc(gfp_flags);
         if (likely(hn)) {
-                heap_node_init(&hn, value);
-                heap_insert(higher_prio, heap, hn);
+                bheap_node_init(&hn, value);
+                bheap_insert(higher_prio, heap, hn);
         }
         return hn != NULL;
 }
 
-void* heap_take_del(heap_prio_t higher_prio,
-                    struct heap* heap)
+void* bheap_take_del(bheap_prio_t higher_prio,
+                    struct bheap* heap)
 {
-        struct heap_node* hn = heap_take(higher_prio, heap);
+        struct bheap_node* hn = bheap_take(higher_prio, heap);
         void* ret = NULL;
         if (hn) {
                 ret = hn->value;
-                heap_node_free(hn);
+                bheap_node_free(hn);
         }
         return ret;
 }
diff --git a/litmus/edf_common.c b/litmus/edf_common.c
index 97e37761cedc..06daec66c984 100644
--- a/litmus/edf_common.c
+++ b/litmus/edf_common.c
@@ -68,9 +68,9 @@ int edf_higher_prio(struct task_struct* first,
                  !second->rt_param.inh_task))));
 }
 
-int edf_ready_order(struct heap_node* a, struct heap_node* b)
+int edf_ready_order(struct bheap_node* a, struct bheap_node* b)
 {
-        return edf_higher_prio(heap2task(a), heap2task(b));
+        return edf_higher_prio(bheap2task(a), bheap2task(b));
 }
 
 void edf_domain_init(rt_domain_t* rt, check_resched_needed_t resched,
diff --git a/litmus/litmus.c b/litmus/litmus.c
index de751a14d77c..2dea340aea1d 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -15,7 +15,7 @@
 #include <linux/sched.h>
 #include <litmus/sched_plugin.h>
 
-#include <litmus/heap.h>
+#include <litmus/bheap.h>
 
 #include <litmus/trace.h>
 
@@ -31,17 +31,17 @@ atomic_t __log_seq_no = ATOMIC_INIT(0);
 /* current master CPU for handling timer IRQs */
 atomic_t release_master_cpu = ATOMIC_INIT(NO_CPU);
 
-static struct kmem_cache * heap_node_cache;
+static struct kmem_cache * bheap_node_cache;
 extern struct kmem_cache * release_heap_cache;
 
-struct heap_node* heap_node_alloc(int gfp_flags)
+struct bheap_node* bheap_node_alloc(int gfp_flags)
 {
-        return kmem_cache_alloc(heap_node_cache, gfp_flags);
+        return kmem_cache_alloc(bheap_node_cache, gfp_flags);
 }
 
-void heap_node_free(struct heap_node* hn)
+void bheap_node_free(struct bheap_node* hn)
 {
-        kmem_cache_free(heap_node_cache, hn);
+        kmem_cache_free(bheap_node_cache, hn);
 }
 
 struct release_heap* release_heap_alloc(int gfp_flags);
@@ -323,19 +323,19 @@ long litmus_admit_task(struct task_struct* tsk)
         spin_lock_irqsave(&task_transition_lock, flags);
 
         /* allocate heap node for this task */
-        tsk_rt(tsk)->heap_node = heap_node_alloc(GFP_ATOMIC);
+        tsk_rt(tsk)->heap_node = bheap_node_alloc(GFP_ATOMIC);
         tsk_rt(tsk)->rel_heap = release_heap_alloc(GFP_ATOMIC);
 
         if (!tsk_rt(tsk)->heap_node || !tsk_rt(tsk)->rel_heap) {
                 printk(KERN_WARNING "litmus: no more heap node memory!?\n");
 
-                heap_node_free(tsk_rt(tsk)->heap_node);
+                bheap_node_free(tsk_rt(tsk)->heap_node);
                 release_heap_free(tsk_rt(tsk)->rel_heap);
 
                 retval = -ENOMEM;
                 goto out_unlock;
         } else {
-                heap_node_init(&tsk_rt(tsk)->heap_node, tsk);
+                bheap_node_init(&tsk_rt(tsk)->heap_node, tsk);
         }
 
         retval = litmus->admit_task(tsk);
@@ -359,8 +359,8 @@ void litmus_exit_task(struct task_struct* tsk)
 
                 litmus->task_exit(tsk);
 
-                BUG_ON(heap_node_in_heap(tsk_rt(tsk)->heap_node));
-                heap_node_free(tsk_rt(tsk)->heap_node);
+                BUG_ON(bheap_node_in_heap(tsk_rt(tsk)->heap_node));
+                bheap_node_free(tsk_rt(tsk)->heap_node);
                 release_heap_free(tsk_rt(tsk)->rel_heap);
 
                 atomic_dec(&rt_task_count);
@@ -648,7 +648,7 @@ static int __init _init_litmus(void)
 
         register_sched_plugin(&linux_sched_plugin);
 
-        heap_node_cache    = KMEM_CACHE(heap_node, SLAB_PANIC);
+        bheap_node_cache    = KMEM_CACHE(bheap_node, SLAB_PANIC);
         release_heap_cache = KMEM_CACHE(release_heap, SLAB_PANIC);
 
 #ifdef CONFIG_MAGIC_SYSRQ
@@ -667,7 +667,7 @@ static int __init _init_litmus(void)
 static void _exit_litmus(void)
 {
         exit_litmus_proc();
-        kmem_cache_destroy(heap_node_cache);
+        kmem_cache_destroy(bheap_node_cache);
         kmem_cache_destroy(release_heap_cache);
 }
 
diff --git a/litmus/rt_domain.c b/litmus/rt_domain.c
index 62c9fdcd22be..0ed6d5cbbfc5 100644
--- a/litmus/rt_domain.c
+++ b/litmus/rt_domain.c
@@ -19,20 +19,20 @@
 
 #include <litmus/trace.h>
 
-#include <litmus/heap.h>
+#include <litmus/bheap.h>
 
 static int dummy_resched(rt_domain_t *rt)
 {
         return 0;
 }
 
-static int dummy_order(struct heap_node* a, struct heap_node* b)
+static int dummy_order(struct bheap_node* a, struct bheap_node* b)
 {
         return 0;
 }
 
 /* default implementation: use default lock */
-static void default_release_jobs(rt_domain_t* rt, struct heap* tasks)
+static void default_release_jobs(rt_domain_t* rt, struct bheap* tasks)
 {
         merge_ready(rt, tasks);
 }
@@ -157,7 +157,7 @@ static void reinit_release_heap(struct task_struct* t)
         BUG_ON(hrtimer_cancel(&rh->timer));
 
         /* initialize */
-        heap_init(&rh->heap);
+        bheap_init(&rh->heap);
         atomic_set(&rh->info.state, HRTIMER_START_ON_INACTIVE);
 }
 /* arm_release_timer() - start local release timer or trigger
@@ -204,7 +204,7 @@ static void arm_release_timer(rt_domain_t *_rt)
 
                         rh = get_release_heap(rt, t, 1);
                 }
-                heap_insert(rt->order, &rh->heap, tsk_rt(t)->heap_node);
+                bheap_insert(rt->order, &rh->heap, tsk_rt(t)->heap_node);
                 TRACE_TASK(t, "arm_release_timer(): added to release heap\n");
 
                 spin_unlock(&rt->release_lock);
@@ -236,7 +236,7 @@ static void arm_release_timer(rt_domain_t *_rt)
 }
 
 void rt_domain_init(rt_domain_t *rt,
-                    heap_prio_t order,
+                    bheap_prio_t order,
                     check_resched_needed_t check,
                     release_jobs_t release
                    )
@@ -253,7 +253,7 @@ void rt_domain_init(rt_domain_t *rt,
 
         rt->release_master = NO_CPU;
 
-        heap_init(&rt->ready_queue);
+        bheap_init(&rt->ready_queue);
         INIT_LIST_HEAD(&rt->tobe_released);
         for (i = 0; i < RELEASE_QUEUE_SLOTS; i++)
                 INIT_LIST_HEAD(&rt->release_queue.slot[i]);
@@ -276,18 +276,18 @@ void __add_ready(rt_domain_t* rt, struct task_struct *new)
               new->comm, new->pid, get_exec_cost(new), get_rt_period(new),
               get_release(new), litmus_clock());
 
-        BUG_ON(heap_node_in_heap(tsk_rt(new)->heap_node));
+        BUG_ON(bheap_node_in_heap(tsk_rt(new)->heap_node));
 
-        heap_insert(rt->order, &rt->ready_queue, tsk_rt(new)->heap_node);
+        bheap_insert(rt->order, &rt->ready_queue, tsk_rt(new)->heap_node);
         rt->check_resched(rt);
 }
 
 /* merge_ready - Add a sorted set of tasks to the rt ready queue. They must be runnable.
  * @tasks      - the newly released tasks
  */
-void __merge_ready(rt_domain_t* rt, struct heap* tasks)
+void __merge_ready(rt_domain_t* rt, struct bheap* tasks)
 {
-        heap_union(rt->order, &rt->ready_queue, tasks);
+        bheap_union(rt->order, &rt->ready_queue, tasks);
         rt->check_resched(rt);
 }
 
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index a223e69f2efb..9f256be86cf7 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -18,7 +18,7 @@
 #include <litmus/edf_common.h>
 #include <litmus/sched_trace.h>
 
-#include <litmus/heap.h>
+#include <litmus/bheap.h>
 
 #include <linux/module.h>
 
@@ -96,7 +96,7 @@ typedef struct  {
         struct task_struct*     linked;         /* only RT tasks */
         struct task_struct*     scheduled;      /* only RT tasks */
         atomic_t                will_schedule;  /* prevent unneeded IPIs */
-        struct heap_node*       hn;
+        struct bheap_node*      hn;
 } cpu_entry_t;
 DEFINE_PER_CPU(cpu_entry_t, gsnedf_cpu_entries);
 
@@ -111,14 +111,14 @@ cpu_entry_t* gsnedf_cpus[NR_CPUS];
 
 
 /* the cpus queue themselves according to priority in here */
-static struct heap_node gsnedf_heap_node[NR_CPUS];
-static struct heap      gsnedf_cpu_heap;
+static struct bheap_node gsnedf_heap_node[NR_CPUS];
+static struct bheap      gsnedf_cpu_heap;
 
 static rt_domain_t gsnedf;
 #define gsnedf_lock (gsnedf.ready_lock)
 
 
-static int cpu_lower_prio(struct heap_node *_a, struct heap_node *_b)
+static int cpu_lower_prio(struct bheap_node *_a, struct bheap_node *_b)
 {
         cpu_entry_t *a, *b;
         a = _a->value;
@@ -134,16 +134,16 @@ static int cpu_lower_prio(struct heap_node *_a, struct heap_node *_b)
  */
 static void update_cpu_position(cpu_entry_t *entry)
 {
-        if (likely(heap_node_in_heap(entry->hn)))
-                heap_delete(cpu_lower_prio, &gsnedf_cpu_heap, entry->hn);
-        heap_insert(cpu_lower_prio, &gsnedf_cpu_heap, entry->hn);
+        if (likely(bheap_node_in_heap(entry->hn)))
+                bheap_delete(cpu_lower_prio, &gsnedf_cpu_heap, entry->hn);
+        bheap_insert(cpu_lower_prio, &gsnedf_cpu_heap, entry->hn);
 }
 
 /* caller must hold gsnedf lock */
 static cpu_entry_t* lowest_prio_cpu(void)
 {
-        struct heap_node* hn;
-        hn = heap_peek(cpu_lower_prio, &gsnedf_cpu_heap);
+        struct bheap_node* hn;
+        hn = bheap_peek(cpu_lower_prio, &gsnedf_cpu_heap);
         return hn->value;
 }
 
@@ -304,7 +304,7 @@ static noinline void gsnedf_job_arrival(struct task_struct* task)
         check_for_preemptions();
 }
 
-static void gsnedf_release_jobs(rt_domain_t* rt, struct heap* tasks)
+static void gsnedf_release_jobs(rt_domain_t* rt, struct bheap* tasks)
 {
         unsigned long flags;
 
@@ -628,9 +628,9 @@ static void update_queue_position(struct task_struct *holder)
                  * We can't use heap_decrease() here since
                  * the cpu_heap is ordered in reverse direction, so
                  * it is actually an increase. */
-                heap_delete(cpu_lower_prio, &gsnedf_cpu_heap,
+                bheap_delete(cpu_lower_prio, &gsnedf_cpu_heap,
                             gsnedf_cpus[tsk_rt(holder)->linked_on]->hn);
-                heap_insert(cpu_lower_prio, &gsnedf_cpu_heap,
+                bheap_insert(cpu_lower_prio, &gsnedf_cpu_heap,
                             gsnedf_cpus[tsk_rt(holder)->linked_on]->hn);
         } else {
                 /* holder may be queued: first stop queue changes */
@@ -642,7 +642,7 @@ static void update_queue_position(struct task_struct *holder)
                          * of holder in some heap. Note that this
                          * may be a release heap. */
                         check_preempt =
-                                !heap_decrease(edf_ready_order,
+                                !bheap_decrease(edf_ready_order,
                                                tsk_rt(holder)->heap_node);
                 } else {
                         /* Nothing to do: if it is not queued and not linked
@@ -664,7 +664,7 @@ static void update_queue_position(struct task_struct *holder)
                         /* heap_decrease() hit the top level of the heap: make
                          * sure preemption checks get the right task, not the
                          * potentially stale cache. */
-                        heap_uncache_min(edf_ready_order,
+                        bheap_uncache_min(edf_ready_order,
                                          &gsnedf.ready_queue);
                         check_for_preemptions();
                 }
@@ -770,12 +770,12 @@ static long gsnedf_activate_plugin(void)
         int cpu;
         cpu_entry_t *entry;
 
-        heap_init(&gsnedf_cpu_heap);
+        bheap_init(&gsnedf_cpu_heap);
         gsnedf.release_master = atomic_read(&release_master_cpu);
 
         for_each_online_cpu(cpu) {
                 entry = &per_cpu(gsnedf_cpu_entries, cpu);
-                heap_node_init(&entry->hn, entry);
+                bheap_node_init(&entry->hn, entry);
                 atomic_set(&entry->will_schedule, 0);
                 entry->linked    = NULL;
                 entry->scheduled = NULL;
@@ -816,7 +816,7 @@ static int __init init_gsn_edf(void)
         int cpu;
         cpu_entry_t *entry;
 
-        heap_init(&gsnedf_cpu_heap);
+        bheap_init(&gsnedf_cpu_heap);
         /* initialize CPU state */
         for (cpu = 0; cpu < NR_CPUS; cpu++)  {
                 entry = &per_cpu(gsnedf_cpu_entries, cpu);
@@ -824,7 +824,7 @@ static int __init init_gsn_edf(void)
                 atomic_set(&entry->will_schedule, 0);
                 entry->cpu       = cpu;
                 entry->hn        = &gsnedf_heap_node[cpu];
-                heap_node_init(&entry->hn, entry);
+                bheap_node_init(&entry->hn, entry);
         }
         edf_domain_init(&gsnedf, NULL, gsnedf_release_jobs);
         return register_sched_plugin(&gsn_edf_plugin);