migrate prio deque to prio lists

src/core/task.h

@@ -138,6 +138,7 @@ int _starpu_task_wait_for_all_in_ctx_and_return_nb_waited_tasks(unsigned sched_c
 
 #ifdef BUILDING_STARPU
 LIST_CREATE_TYPE_NOSTRUCT(starpu_task, prev, next);
+PRIO_LIST_CREATE_TYPE(starpu_task, priority);
 #define __STARPU_TASK_LIST_H__
 #endif
 

src/sched_policies/prio_deque.c

@@ -19,79 +19,6 @@
 #include "prio_deque.h"
 
 
-void _starpu_prio_deque_init(struct _starpu_prio_deque * pdeque)
-{
-	STARPU_ASSERT(pdeque);
-	memset(pdeque,0,sizeof(*pdeque));
-}
-void _starpu_prio_deque_destroy(struct _starpu_prio_deque * pdeque)
-{
-	STARPU_ASSERT(pdeque);
-	int i;
-	for(i = 0; i < pdeque->size_array; i++)
-	{
-		STARPU_ASSERT(starpu_task_list_empty(&pdeque->array[i].list));
-	}
-	free(pdeque->array);
-}
-
-int _starpu_prio_deque_is_empty(struct _starpu_prio_deque * pdeque)
-{
-	STARPU_ASSERT(pdeque);
-	return pdeque->ntasks == 0;
-}
-
-
-/* return the struct starpu_prio_list * of prio,
- * create it and return it if none exist yet
- */
-static struct starpu_task_list * get_prio(struct _starpu_prio_deque * pdeque, int prio)
-{
-	STARPU_ASSERT(pdeque);
-	int i;
-	for(i = 0; i < pdeque->size_array; i++)
-	{
-		if(pdeque->array[i].prio == prio)
-		{
-			return &pdeque->array[i].list;
-		}
-		else
-			if(pdeque->array[i].prio < prio)
-				break;
-	}
-	pdeque->size_array++;
-	_STARPU_REALLOC(pdeque->array, sizeof(struct _starpu_prio_list) * (pdeque->size_array));
-	memmove(pdeque->array + i + 1,
-		pdeque->array + i,
-		(pdeque->size_array - i - 1) * sizeof(struct _starpu_prio_list));
-	pdeque->array[i].prio = prio;
-	starpu_task_list_init(&pdeque->array[i].list);
-	return &pdeque->array[i].list;
-}
-
-
-
-int _starpu_prio_deque_push_task(struct _starpu_prio_deque * pdeque, struct starpu_task * task)
-{
-	STARPU_ASSERT(pdeque && task);
-	struct starpu_task_list * list = get_prio(pdeque, task->priority);
-	starpu_task_list_push_back(list, task);
-	pdeque->ntasks++;
-	return 0;
-}
-
-int _starpu_prio_deque_push_back_task(struct _starpu_prio_deque * pdeque, struct starpu_task * task)
-{
-	STARPU_ASSERT(pdeque && task);
-	struct starpu_task_list * list = get_prio(pdeque, task->priority);
-	starpu_task_list_push_front(list, task);
-	pdeque->ntasks++;
-	return 0;
-}
-
-
-
-
 /* a little dirty code factorization */
 
 static inline int pred_true(struct starpu_task * t STARPU_ATTRIBUTE_UNUSED, void * v STARPU_ATTRIBUTE_UNUSED)
@@ -109,31 +36,23 @@ static inline int pred_can_execute(struct starpu_task * t, void * pworkerid)
 }
 
 #define REMOVE_TASK(pdeque, first_task_field, next_task_field, predicate, parg)	\
-	{								\
-		int i;							\
-		struct starpu_task * t = NULL;				\
-		for(i = 0; i < pdeque->size_array; i++)			\
-		{							\
-			t = pdeque->array[i].list.first_task_field;	\
-			while(t && !predicate(t,parg))			\
-				t = t->next_task_field;			\
-			if(t)						\
-			{						\
-				starpu_task_list_erase(&pdeque->array[i].list, t); \
-				pdeque->ntasks--;			\
-				return t;				\
-			}						\
-		}							\
-		return NULL;						\
+	{									\
+		struct starpu_task * t;						\
+		for (t  = starpu_task_prio_list_begin(&pdeque->list);		\
+		     t != starpu_task_prio_list_end(&pdeque->list);		\
+		     t  = starpu_task_prio_list_next(&pdeque->list, t))		\
+		{								\
+			if (predicate(t, parg))					\
+				starpu_task_prio_list_erase(&pdeque->list, t);	\
+				pdeque->ntasks--;				\
+				return t;					\
+		}								\
+		return NULL;							\
 	}
 
 /* deque a task of the higher priority available */
 
 /* From the front of the list for the highest priority */
-struct starpu_task * _starpu_prio_deque_pop_task(struct _starpu_prio_deque * pdeque)
-{
-	REMOVE_TASK(pdeque, _head, prev, pred_true, STARPU_POISON_PTR);
-}
 struct starpu_task * _starpu_prio_deque_pop_task_for_worker(struct _starpu_prio_deque * pdeque, int workerid)
 {
 	STARPU_ASSERT(pdeque);
@@ -142,12 +61,6 @@ struct starpu_task * _starpu_prio_deque_pop_task_for_worker(struct _starpu_prio_
 }
 
 /* From the back of the list for the highest priority */
-struct starpu_task * _starpu_prio_deque_deque_task(struct _starpu_prio_deque * pdeque)
-{
-	STARPU_ASSERT(pdeque);
-	REMOVE_TASK(pdeque, _tail, next, pred_true, STARPU_POISON_PTR);
-}
-
 struct starpu_task * _starpu_prio_deque_deque_task_for_worker(struct _starpu_prio_deque * pdeque, int workerid)
 {
 	STARPU_ASSERT(pdeque);

src/sched_policies/prio_deque.h

@@ -19,44 +19,73 @@
 #include <core/task.h>
 
 
-struct _starpu_prio_list
-{
-	int prio;
-	struct starpu_task_list list;
-};
-
 struct _starpu_prio_deque
 {
-	struct _starpu_prio_list * array;
+	struct starpu_task_prio_list list;
 	int size_array;
 	unsigned ntasks;
 	unsigned nprocessed;
 	double exp_start, exp_end, exp_len;
 };
 
-void _starpu_prio_deque_init(struct _starpu_prio_deque *);
-void _starpu_prio_deque_destroy(struct _starpu_prio_deque *);
+static inline void _starpu_prio_deque_init(struct _starpu_prio_deque *pdeque)
+{
+	memset(pdeque,0,sizeof(*pdeque));
+	starpu_task_prio_list_init(&pdeque->list);
+}
+
+static inline void _starpu_prio_deque_destroy(struct _starpu_prio_deque *pdeque)
+{
+	starpu_task_prio_list_deinit(&pdeque->list);
+}
 
 /* return 0 iff the struct _starpu_prio_deque is not empty */
-int _starpu_prio_deque_is_empty(struct _starpu_prio_deque *);
+static int _starpu_prio_deque_is_empty(struct _starpu_prio_deque *pdeque)
+{
+	return pdeque->ntasks == 0;
+}
 
-/* push a task in O(nb priorities) */
-int _starpu_prio_deque_push_task(struct _starpu_prio_deque *, struct starpu_task *);
+/* push a task in O(lg(nb priorities)) */
+static inline int _starpu_prio_deque_push_task(struct _starpu_prio_deque *pdeque, struct starpu_task *task)
+{
+	starpu_task_prio_list_push_front(&pdeque->list, task);
+	pdeque->ntasks++;
+	return 0;
+}
+static inline int _starpu_prio_deque_push_back_task(struct _starpu_prio_deque *pdeque, struct starpu_task *task)
+{
+	starpu_task_prio_list_push_back(&pdeque->list, task);
+	pdeque->ntasks++;
+	return 0;
+}
 int _starpu_prio_deque_push_back_task(struct _starpu_prio_deque *, struct starpu_task *);
 
 
 /* all _starpu_prio_deque_pop/deque_task function return a task or a NULL pointer if none are available
- * in O(nb priorities)
+ * in O(lg(nb priorities))
  */
 
-struct starpu_task * _starpu_prio_deque_pop_task(struct _starpu_prio_deque *);
+static inline struct starpu_task * _starpu_prio_deque_pop_task(struct _starpu_prio_deque *pdeque)
+{
+	struct starpu_task *task = starpu_task_prio_list_pop_front(&pdeque->list);
+	if (task)
+		pdeque->ntasks--;
+	return task;
+}
 
 /* return a task that can be executed by workerid
  */
 struct starpu_task * _starpu_prio_deque_pop_task_for_worker(struct _starpu_prio_deque *, int workerid);
 
 /* deque a task of the higher priority available */
-struct starpu_task * _starpu_prio_deque_deque_task(struct _starpu_prio_deque *);
+static inline struct starpu_task * _starpu_prio_deque_deque_task(struct _starpu_prio_deque *pdeque)
+{
+	struct starpu_task *task = starpu_task_prio_list_pop_back(&pdeque->list);
+	if (task)
+		pdeque->ntasks--;
+	return task;
+}
+
 /* return a task that can be executed by workerid
  */
 struct starpu_task * _starpu_prio_deque_deque_task_for_worker(struct _starpu_prio_deque *, int workerid);