Inline list heads instead of keeping allocating them

src/common/list.h

@@ -34,6 +34,8 @@
  *   void		FOO_delete(struct FOO*);
  *     * création d'une liste (vide)
  *   struct FOO_list*	FOO_list_new(void);
+ *     * initialisation d'une liste (vide)
+ *   void		FOO_list_init(struct FOO_list*);
  *     * suppression d'une liste
  *   void		FOO_list_delete(struct FOO_list*);
  *     * teste si une liste est vide
@@ -152,9 +154,11 @@
     { return l->_head; } \
   /** @internal */static inline struct ENAME *ENAME##_list_back(struct ENAME##_list *l) \
     { return l->_tail; } \
+  /** @internal */static inline void ENAME##_list_init(struct ENAME##_list *l) \
+    { l->_head=NULL; l->_tail=l->_head; } \
   /** @internal */static inline struct ENAME##_list *ENAME##_list_new(void) \
     { struct ENAME##_list *l; l=(struct ENAME##_list *)malloc(sizeof(struct ENAME##_list)); \
-      l->_head=NULL; l->_tail=l->_head; return l; } \
+      ENAME##_list_init(l); return l; } \
   /** @internal */static inline int ENAME##_list_empty(struct ENAME##_list *l) \
     { return (l->_head == NULL); } \
   /** @internal */static inline void ENAME##_list_delete(struct ENAME##_list *l) \

src/core/dependencies/data_arbiter_concurrency.c

@@ -20,6 +20,8 @@
 #include <core/sched_policy.h>
 #include <common/starpu_spinlock.h>
 #include <datawizard/sort_data_handles.h>
+#include <datawizard/memalloc.h>
+#include <datawizard/memory_nodes.h>
 
 /* TODO factorize with data_concurrency.c and btw support redux */
 
@@ -295,7 +297,7 @@ unsigned _starpu_attempt_to_submit_arbitered_data_request(unsigned request_from_
 		r->ready_data_callback = callback;
 		r->argcb = argcb;
 
-		_starpu_data_requester_list_push_back(handle->arbitered_req_list, r);
+		_starpu_data_requester_list_push_back(&handle->arbitered_req_list, r);
 
 		/* failed */
 		put_in_list = 1;
@@ -473,7 +475,7 @@ void _starpu_submit_job_enforce_arbitered_deps(struct _starpu_job *j, unsigned b
 
 			_starpu_spin_lock(&cancel_handle->header_lock);
 			/* store node in list */
-			_starpu_data_requester_list_push_front(cancel_handle->arbitered_req_list, r);
+			_starpu_data_requester_list_push_front(&cancel_handle->arbitered_req_list, r);
 			/* inc the busy count if it has not been changed in the previous loop */
 			if (idx_buf_arbiter <= idx_buf_cancel)
 				cancel_handle->busy_count += 1;
@@ -520,7 +522,7 @@ void _starpu_notify_arbitered_dependencies(starpu_data_handle_t handle)
 #endif
 
 	/* Since the request has been posted the handle may have been proceed and released */
-	if (_starpu_data_requester_list_empty(handle->arbitered_req_list))
+	if (_starpu_data_requester_list_empty(&handle->arbitered_req_list))
 	{
 #ifndef LOCK_OR_DELEGATE
 		STARPU_PTHREAD_MUTEX_UNLOCK(&arbiter->mutex);
@@ -530,8 +532,8 @@ void _starpu_notify_arbitered_dependencies(starpu_data_handle_t handle)
 	/* no one has the right to work on arbitered_req_list without a lock on mutex
 	   so we do not need to lock the handle for safety */
 	struct _starpu_data_requester *r;
-	for (r = _starpu_data_requester_list_begin(handle->arbitered_req_list);
-	     r != _starpu_data_requester_list_end(handle->arbitered_req_list);
+	for (r = _starpu_data_requester_list_begin(&handle->arbitered_req_list);
+	     r != _starpu_data_requester_list_end(&handle->arbitered_req_list);
 	     r = _starpu_data_requester_list_next(r))
 	{
 		if (!r->is_requested_by_codelet)
@@ -546,7 +548,7 @@ void _starpu_notify_arbitered_dependencies(starpu_data_handle_t handle)
 			handle->busy_count++;
 			handle->current_mode = r_mode;
 			_starpu_spin_unlock(&handle->header_lock);
-			_starpu_data_requester_list_erase(handle->arbitered_req_list, r);
+			_starpu_data_requester_list_erase(&handle->arbitered_req_list, r);
 #ifndef LOCK_OR_DELEGATE
 			STARPU_PTHREAD_MUTEX_UNLOCK(&arbiter->mutex);
 #endif
@@ -628,7 +630,7 @@ void _starpu_notify_arbitered_dependencies(starpu_data_handle_t handle)
 				STARPU_ASSERT(handle_arbiter->refcnt == 1);
 				STARPU_ASSERT( handle_arbiter->busy_count >= 1);
 				STARPU_ASSERT( handle_arbiter->current_mode == mode);
-				const unsigned correctly_deleted = remove_job_from_requester_list(handle_arbiter->arbitered_req_list, j);
+				const unsigned correctly_deleted = remove_job_from_requester_list(&handle_arbiter->arbitered_req_list, j);
 				STARPU_ASSERT(correctly_deleted == 0);
 				_starpu_spin_unlock(&handle_arbiter->header_lock);
 			}

src/core/dependencies/data_concurrency.c

@@ -21,6 +21,7 @@
 #include <core/sched_policy.h>
 #include <common/starpu_spinlock.h>
 #include <datawizard/sort_data_handles.h>
+#include <datawizard/memory_nodes.h>
 
 /*
  * We have a kind of dining philosophers problem: various tasks are accessing
@@ -66,14 +67,14 @@ static struct _starpu_data_requester *may_unlock_data_req_list_head(starpu_data_
 
 	if (handle->reduction_refcnt > 0)
 	{
-		req_list = handle->reduction_req_list;
+		req_list = &handle->reduction_req_list;
 	}
 	else
 	{
-		if (_starpu_data_requester_list_empty(handle->reduction_req_list))
-			req_list = handle->req_list;
+		if (_starpu_data_requester_list_empty(&handle->reduction_req_list))
+			req_list = &handle->req_list;
 		else
-			req_list = handle->reduction_req_list;
+			req_list = &handle->reduction_req_list;
 	}
 
 	/* if there is no one to unlock ... */
@@ -196,7 +197,7 @@ static unsigned _starpu_attempt_to_submit_data_request(unsigned request_from_cod
 
 		/* We put the requester in a specific list if this is a reduction task */
 		struct _starpu_data_requester_list *req_list =
-			is_a_reduction_task?handle->reduction_req_list:handle->req_list;
+			is_a_reduction_task?&handle->reduction_req_list:&handle->req_list;
 
 		_starpu_data_requester_list_push_back(req_list, r);
 
@@ -369,8 +370,8 @@ int _starpu_notify_data_dependencies(starpu_data_handle_t handle)
 	if (handle->arbiter)
 	{
 		unsigned refcnt = handle->refcnt;
-		STARPU_ASSERT(_starpu_data_requester_list_empty(handle->req_list));
-		STARPU_ASSERT(_starpu_data_requester_list_empty(handle->reduction_req_list));
+		STARPU_ASSERT(_starpu_data_requester_list_empty(&handle->req_list));
+		STARPU_ASSERT(_starpu_data_requester_list_empty(&handle->reduction_req_list));
 		_starpu_spin_unlock(&handle->header_lock);
 		/* _starpu_notify_arbitered_dependencies will handle its own locking */
 		if (!refcnt)
@@ -378,7 +379,7 @@ int _starpu_notify_data_dependencies(starpu_data_handle_t handle)
 		/* We have already unlocked */
 		return 1;
 	}
-	STARPU_ASSERT(_starpu_data_requester_list_empty(handle->arbitered_req_list));
+	STARPU_ASSERT(_starpu_data_requester_list_empty(&handle->arbitered_req_list));
 
 	/* In case there is a pending reduction, and that this is the last
 	 * requester, we may go back to a "normal" coherency model. */
@@ -416,7 +417,7 @@ int _starpu_notify_data_dependencies(starpu_data_handle_t handle)
 		{
 			/* We need to put the request back because we must
 			 * perform a reduction before. */
-			_starpu_data_requester_list_push_front(handle->req_list, r);
+			_starpu_data_requester_list_push_front(&handle->req_list, r);
 		}
 		else
 		{

src/core/disk.c

@@ -28,6 +28,7 @@
 #include <core/workers.h>
 #include <core/perfmodel/perfmodel.h>
 #include <core/topology.h>
+#include <datawizard/memory_nodes.h>
 #include <datawizard/memory_manager.h>
 #include <datawizard/memalloc.h>
 

src/core/disk_ops/disk_stdio.c

@@ -26,6 +26,7 @@
 #include <core/perfmodel/perfmodel.h>
 #include <datawizard/copy_driver.h>
 #include <datawizard/memory_manager.h>
+#include <datawizard/memory_nodes.h>
 #include <starpu_parameters.h>
 
 #ifdef STARPU_HAVE_WINDOWS

src/core/topology.c

@@ -28,6 +28,7 @@
 #include <drivers/mp_common/source_common.h>
 #include <drivers/opencl/driver_opencl.h>
 #include <profiling/profiling.h>
+#include <datawizard/memory_nodes.h>
 #include <common/uthash.h>
 
 #ifdef STARPU_HAVE_HWLOC

src/core/workers.c

@@ -31,6 +31,7 @@
 #include <profiling/profiling.h>
 #include <starpu_task_list.h>
 #include <sched_policies/sched_component.h>
+#include <datawizard/memory_nodes.h>
 #include <drivers/mp_common/sink_common.h>
 #include <drivers/scc/driver_scc_common.h>
 

src/datawizard/coherency.c

@@ -19,6 +19,7 @@
 #include <datawizard/coherency.h>
 #include <datawizard/copy_driver.h>
 #include <datawizard/write_back.h>
+#include <datawizard/memory_nodes.h>
 #include <core/dependencies/data_concurrency.h>
 #include <core/disk.h>
 #include <profiling/profiling.h>

src/datawizard/coherency.h

@@ -31,6 +31,7 @@
 #include <datawizard/interfaces/data_interface.h>
 #include <datawizard/datastats.h>
 #include <datawizard/memstats.h>
+#include <datawizard/data_request.h>
 
 enum _starpu_cache_state
 {
@@ -114,7 +115,7 @@ typedef void (*_starpu_data_handle_unregister_hook)(starpu_data_handle_t);
 
 struct _starpu_data_state
 {
-	struct _starpu_data_requester_list *req_list;
+	struct _starpu_data_requester_list req_list;
 	/* the number of requests currently in the scheduling engine (not in
 	 * the req_list anymore), i.e. the number of holders of the
 	 * current_mode rwlock */
@@ -215,7 +216,7 @@ struct _starpu_data_state
 	/* List of requesters that are specific to the pending reduction. This
 	 * list is used when the requests in the req_list list are frozen until
 	 * the end of the reduction. */
-	struct _starpu_data_requester_list *reduction_req_list;
+	struct _starpu_data_requester_list reduction_req_list;
 
 	starpu_data_handle_t *reduction_tmp_handles;
 
@@ -237,7 +238,7 @@ struct _starpu_data_state
 
 	struct starpu_arbiter *arbiter;
 	/* This is protected by the arbiter mutex */
-	struct _starpu_data_requester_list *arbitered_req_list;
+	struct _starpu_data_requester_list arbitered_req_list;
 };
 
 void _starpu_display_msi_stats(void);

src/datawizard/copy_driver.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010-2014  Université de Bordeaux
+ * Copyright (C) 2010-2015  Université de Bordeaux
  * Copyright (C) 2010, 2011, 2013  CNRS
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -20,6 +20,7 @@
 #include <common/utils.h>
 #include <core/sched_policy.h>
 #include <datawizard/datastats.h>
+#include <datawizard/memory_nodes.h>
 #include <drivers/disk/driver_disk.h>
 #include <common/fxt.h>
 #include "copy_driver.h"

src/datawizard/copy_driver.h

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010, 2012-2014  Université de Bordeaux
+ * Copyright (C) 2010, 2012-2015  Université de Bordeaux
  * Copyright (C) 2010, 2011, 2013, 2015  CNRS
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -23,9 +23,6 @@
 #endif
 
 #include <common/config.h>
-#include <datawizard/memory_nodes.h>
-#include "coherency.h"
-#include "memalloc.h"
 
 #ifdef STARPU_USE_CUDA
 #include <cuda.h>

src/datawizard/data_request.c

@@ -19,6 +19,7 @@
 #include <common/config.h>
 #include <common/utils.h>
 #include <datawizard/datawizard.h>
+#include <datawizard/memory_nodes.h>
 #include <core/disk.h>
 
 /* TODO: This should be tuned according to driver capabilities
@@ -30,13 +31,13 @@
 #define MAX_PENDING_IDLE_REQUESTS_PER_NODE 1
 
 /* requests that have not been treated at all */
-static struct _starpu_data_request_list *data_requests[STARPU_MAXNODES];
-static struct _starpu_data_request_list *prefetch_requests[STARPU_MAXNODES];
-static struct _starpu_data_request_list *idle_requests[STARPU_MAXNODES];
+static struct _starpu_data_request_list data_requests[STARPU_MAXNODES];
+static struct _starpu_data_request_list prefetch_requests[STARPU_MAXNODES];
+static struct _starpu_data_request_list idle_requests[STARPU_MAXNODES];
 static starpu_pthread_mutex_t data_requests_list_mutex[STARPU_MAXNODES];
 
 /* requests that are not terminated (eg. async transfers) */
-static struct _starpu_data_request_list *data_requests_pending[STARPU_MAXNODES];
+static struct _starpu_data_request_list data_requests_pending[STARPU_MAXNODES];
 static unsigned data_requests_npending[STARPU_MAXNODES];
 static starpu_pthread_mutex_t data_requests_pending_list_mutex[STARPU_MAXNODES];
 
@@ -45,23 +46,20 @@ void _starpu_init_data_request_lists(void)
 	unsigned i;
 	for (i = 0; i < STARPU_MAXNODES; i++)
 	{
-		data_requests[i] = _starpu_data_request_list_new();
-		prefetch_requests[i] = _starpu_data_request_list_new();
-		idle_requests[i] = _starpu_data_request_list_new();
+		_starpu_data_request_list_init(&data_requests[i]);
+		_starpu_data_request_list_init(&prefetch_requests[i]);
+		_starpu_data_request_list_init(&idle_requests[i]);
 
 		/* Tell helgrind that we are fine with checking for list_empty
 		 * in _starpu_handle_node_data_requests, we will call it
 		 * periodically anyway */
-		STARPU_HG_DISABLE_CHECKING(data_requests[i]);
-		STARPU_HG_DISABLE_CHECKING(data_requests[i]->_head);
-		STARPU_HG_DISABLE_CHECKING(prefetch_requests[i]);
-		STARPU_HG_DISABLE_CHECKING(prefetch_requests[i]->_head);
-		STARPU_HG_DISABLE_CHECKING(idle_requests[i]);
-		STARPU_HG_DISABLE_CHECKING(idle_requests[i]->_head);
+		STARPU_HG_DISABLE_CHECKING(data_requests[i]._head);
+		STARPU_HG_DISABLE_CHECKING(prefetch_requests[i]._head);
+		STARPU_HG_DISABLE_CHECKING(idle_requests[i]._head);
 
 		STARPU_PTHREAD_MUTEX_INIT(&data_requests_list_mutex[i], NULL);
 
-		data_requests_pending[i] = _starpu_data_request_list_new();
+		_starpu_data_request_list_init(&data_requests_pending[i]);
 		data_requests_npending[i] = 0;
 		STARPU_PTHREAD_MUTEX_INIT(&data_requests_pending_list_mutex[i], NULL);
 	}
@@ -74,12 +72,7 @@ void _starpu_deinit_data_request_lists(void)
 	for (i = 0; i < STARPU_MAXNODES; i++)
 	{
 		STARPU_PTHREAD_MUTEX_DESTROY(&data_requests_pending_list_mutex[i]);
-		_starpu_data_request_list_delete(data_requests_pending[i]);
-
 		STARPU_PTHREAD_MUTEX_DESTROY(&data_requests_list_mutex[i]);
-		_starpu_data_request_list_delete(data_requests[i]);
-		_starpu_data_request_list_delete(prefetch_requests[i]);
-		_starpu_data_request_list_delete(idle_requests[i]);
 	}
 }
 
@@ -244,11 +237,11 @@ void _starpu_post_data_request(struct _starpu_data_request *r, unsigned handling
 	/* insert the request in the proper list */
 	STARPU_PTHREAD_MUTEX_LOCK(&data_requests_list_mutex[handling_node]);
 	if (r->prefetch == 2)
-		_starpu_data_request_list_push_back(idle_requests[handling_node], r);
+		_starpu_data_request_list_push_back(&idle_requests[handling_node], r);
 	else if (r->prefetch)
-		_starpu_data_request_list_push_back(prefetch_requests[handling_node], r);
+		_starpu_data_request_list_push_back(&prefetch_requests[handling_node], r);
 	else
-		_starpu_data_request_list_push_back(data_requests[handling_node], r);
+		_starpu_data_request_list_push_back(&data_requests[handling_node], r);
 	STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[handling_node]);
 
 #ifndef STARPU_NON_BLOCKING_DRIVERS
@@ -437,7 +430,7 @@ static int starpu_handle_data_request(struct _starpu_data_request *r, unsigned m
 		_starpu_spin_unlock(&handle->header_lock);
 
 		STARPU_PTHREAD_MUTEX_LOCK(&data_requests_pending_list_mutex[r->handling_node]);
-		_starpu_data_request_list_push_back(data_requests_pending[r->handling_node], r);
+		_starpu_data_request_list_push_back(&data_requests_pending[r->handling_node], r);
 		data_requests_npending[r->handling_node]++;
 		STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_pending_list_mutex[r->handling_node]);
 
@@ -451,11 +444,10 @@ static int starpu_handle_data_request(struct _starpu_data_request *r, unsigned m
 	return 0;
 }
 
-int __starpu_handle_node_data_requests(struct _starpu_data_request_list **reqlist, unsigned src_node, unsigned may_alloc, unsigned n, unsigned *pushed, unsigned prefetch)
+static int __starpu_handle_node_data_requests(struct _starpu_data_request_list *reqlist, unsigned src_node, unsigned may_alloc, unsigned n, unsigned *pushed, unsigned prefetch)
 {
 	struct _starpu_data_request *r;
-	struct _starpu_data_request_list *new_data_requests[prefetch + 1]; /* Indexed by prefetch level */
-	struct _starpu_data_request_list *empty_list;
+	struct _starpu_data_request_list new_data_requests[prefetch + 1]; /* Indexed by prefetch level */
 	unsigned i;
 	int ret = 0;
 
@@ -465,47 +457,43 @@ int __starpu_handle_node_data_requests(struct _starpu_data_request_list **reqlis
 	/* This is racy, but not posing problems actually, since we know we
 	 * will come back here to probe again regularly anyway.
 	 * Thus, do not expose this optimization to helgrind */
-	if (!RUNNING_ON_VALGRIND && _starpu_data_request_list_empty(reqlist[src_node]))
+	if (!RUNNING_ON_VALGRIND && _starpu_data_request_list_empty(&reqlist[src_node]))
 		return 0;
 #endif
 
-	empty_list = _starpu_data_request_list_new();
+	/* TODO optimize */
 
 #ifdef STARPU_NON_BLOCKING_DRIVERS
 	/* take all the entries from the request list */
 	if (STARPU_PTHREAD_MUTEX_TRYLOCK(&data_requests_list_mutex[src_node]))
 	{
 		/* List is busy, do not bother with it */
-		_starpu_data_request_list_delete(empty_list);
 		return -EBUSY;
 	}
 #else
 	STARPU_PTHREAD_MUTEX_LOCK(&data_requests_list_mutex[src_node]);
 #endif
 
-	struct _starpu_data_request_list *local_list = reqlist[src_node];
-
-	if (_starpu_data_request_list_empty(local_list))
+	if (_starpu_data_request_list_empty(&reqlist[src_node]))
 	{
 		/* there is no request */
                 STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[src_node]);
-		_starpu_data_request_list_delete(empty_list);
 		return 0;
 	}
 
 	/* There is an entry: we create a new empty list to replace the list of
 	 * requests, and we handle the request(s) one by one in the former
 	 * list, without concurrency issues.*/
-	reqlist[src_node] = empty_list;
-	STARPU_HG_DISABLE_CHECKING(reqlist[src_node]->_head);
+	struct _starpu_data_request_list local_list = reqlist[src_node];
+	_starpu_data_request_list_init(&reqlist[src_node]);
 
 	STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[src_node]);
 
 	for (i = 0; i <= prefetch; i++)
-		new_data_requests[i] = _starpu_data_request_list_new();
+		_starpu_data_request_list_init(&new_data_requests[i]);
 
 	/* for all entries of the list */
-	while (!_starpu_data_request_list_empty(local_list))
+	while (!_starpu_data_request_list_empty(&local_list))
 	{
                 int res;
 
@@ -517,7 +505,7 @@ int __starpu_handle_node_data_requests(struct _starpu_data_request_list **reqlis
 			break;
 		}
 
-		r = _starpu_data_request_list_pop_front(local_list);
+		r = _starpu_data_request_list_pop_front(&local_list);
 
 		res = starpu_handle_data_request(r, may_alloc, prefetch);
 		if (res != 0 && res != -EAGAIN)
@@ -525,7 +513,7 @@ int __starpu_handle_node_data_requests(struct _starpu_data_request_list **reqlis
 			/* handle is busy, or not enough memory, postpone for now */
 			ret = res;
 			/* Prefetch requests might have gotten promoted while in tmp list */
-			_starpu_data_request_list_push_back(new_data_requests[r->prefetch], r);
+			_starpu_data_request_list_push_back(&new_data_requests[r->prefetch], r);
 			break;
 		}
 
@@ -533,26 +521,26 @@ int __starpu_handle_node_data_requests(struct _starpu_data_request_list **reqlis
 	}
 
 	/* Push back requests we didn't handle on the proper list */
-	while (!_starpu_data_request_list_empty(local_list))
+	while (!_starpu_data_request_list_empty(&local_list))
 	{
-		r = _starpu_data_request_list_pop_front(local_list);
+		r = _starpu_data_request_list_pop_front(&local_list);
 		/* Prefetch requests might have gotten promoted while in tmp list */
-		_starpu_data_request_list_push_back(new_data_requests[r->prefetch], r);
+		_starpu_data_request_list_push_back(&new_data_requests[r->prefetch], r);
 	}
 
 	for (i = 0; i <= prefetch; i++)
-		if (!_starpu_data_request_list_empty(new_data_requests[i]))
+		if (!_starpu_data_request_list_empty(&new_data_requests[i]))
 			break;
 
 	if (i <= prefetch)
 	{
 		STARPU_PTHREAD_MUTEX_LOCK(&data_requests_list_mutex[src_node]);
-		if (!(_starpu_data_request_list_empty(new_data_requests[0])))
-			_starpu_data_request_list_push_list_front(new_data_requests[0], data_requests[src_node]);
-		if (prefetch >= 1 && !(_starpu_data_request_list_empty(new_data_requests[1])))
-			_starpu_data_request_list_push_list_front(new_data_requests[1], prefetch_requests[src_node]);
-		if (prefetch >= 2 && !(_starpu_data_request_list_empty(new_data_requests[2])))
-			_starpu_data_request_list_push_list_front(new_data_requests[2], idle_requests[src_node]);
+		if (!(_starpu_data_request_list_empty(&new_data_requests[0])))
+			_starpu_data_request_list_push_list_front(&new_data_requests[0], &data_requests[src_node]);
+		if (prefetch >= 1 && !(_starpu_data_request_list_empty(&new_data_requests[1])))
+			_starpu_data_request_list_push_list_front(&new_data_requests[1], &prefetch_requests[src_node]);
+		if (prefetch >= 2 && !(_starpu_data_request_list_empty(&new_data_requests[2])))
+			_starpu_data_request_list_push_list_front(&new_data_requests[2], &idle_requests[src_node]);
 		STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[src_node]);
 
 #ifndef STARPU_NON_BLOCKING_DRIVERS
@@ -560,11 +548,6 @@ int __starpu_handle_node_data_requests(struct _starpu_data_request_list **reqlis
 #endif
 	}
 
-	for (i = 0; i <= prefetch; i++)
-		_starpu_data_request_list_delete(new_data_requests[i]);
-	_starpu_data_request_list_delete(local_list);
-
-
 	return ret;
 }
 
@@ -587,26 +570,25 @@ static int _handle_pending_node_data_requests(unsigned src_node, unsigned force)
 {
 //	_STARPU_DEBUG("_starpu_handle_pending_node_data_requests ...\n");
 //
-	struct _starpu_data_request_list *new_data_requests_pending;
-	struct _starpu_data_request_list *empty_list;
+	struct _starpu_data_request_list new_data_requests_pending;
+	struct _starpu_data_request_list empty_list;
 	unsigned taken, kept;
 
 #ifdef STARPU_NON_BLOCKING_DRIVERS
 	/* Here helgrind would should that this is an un protected access.
 	 * We however don't care about missing an entry, we will get called
 	 * again sooner or later. */
-	if (!RUNNING_ON_VALGRIND && _starpu_data_request_list_empty(data_requests_pending[src_node]))
+	if (!RUNNING_ON_VALGRIND && _starpu_data_request_list_empty(&data_requests_pending[src_node]))
 		return 0;
 #endif
 
-	empty_list = _starpu_data_request_list_new();
+	_starpu_data_request_list_init(&empty_list);
 #ifdef STARPU_NON_BLOCKING_DRIVERS
 	if (!force)
 	{
 		if (STARPU_PTHREAD_MUTEX_TRYLOCK(&data_requests_pending_list_mutex[src_node]))
 		{
 			/* List is busy, do not bother with it */
-			_starpu_data_request_list_delete(empty_list);
 			return 0;
 		}
 	}
@@ -615,27 +597,26 @@ static int _handle_pending_node_data_requests(unsigned src_node, unsigned force)
 		/* We really want to handle requests */
 		STARPU_PTHREAD_MUTEX_LOCK(&data_requests_pending_list_mutex[src_node]);
 
-	/* for all entries of the list */
-	struct _starpu_data_request_list *local_list = data_requests_pending[src_node];
-	if (_starpu_data_request_list_empty(local_list))
+	if (_starpu_data_request_list_empty(&data_requests_pending[src_node]))
 	{
 		/* there is no request */
 		STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_pending_list_mutex[src_node]);
-		_starpu_data_request_list_delete(empty_list);
 		return 0;
 	}
-	data_requests_pending[src_node] = empty_list;
+	/* for all entries of the list */
+	struct _starpu_data_request_list local_list = data_requests_pending[src_node];
+	_starpu_data_request_list_init(&data_requests_pending[src_node]);
 
 	STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_pending_list_mutex[src_node]);
 
-	new_data_requests_pending = _starpu_data_request_list_new();
+	_starpu_data_request_list_init(&new_data_requests_pending);
 	taken = 0;
 	kept = 0;
 
-	while (!_starpu_data_request_list_empty(local_list))
+	while (!_starpu_data_request_list_empty(&local_list))
 	{
 		struct _starpu_data_request *r;
-		r = _starpu_data_request_list_pop_front(local_list);
+		r = _starpu_data_request_list_pop_front(&local_list);
 		taken++;
 
 		starpu_data_handle_t handle = r->handle;
@@ -653,7 +634,7 @@ static int _handle_pending_node_data_requests(unsigned src_node, unsigned force)
 			if (_starpu_spin_trylock(&handle->header_lock))
 			{
 				/* Handle is busy, retry this later */
-				_starpu_data_request_list_push_back(new_data_requests_pending, r);
+				_starpu_data_request_list_push_back(&new_data_requests_pending, r);
 				kept++;
 				continue;
 			}
@@ -683,7 +664,7 @@ static int _handle_pending_node_data_requests(unsigned src_node, unsigned force)
 				_starpu_spin_unlock(&r->lock);
 				_starpu_spin_unlock(&handle->header_lock);
 
-				_starpu_data_request_list_push_back(new_data_requests_pending, r);
+				_starpu_data_request_list_push_back(&new_data_requests_pending, r);
 				kept++;
 			}
 		}
@@ -691,12 +672,9 @@ static int _handle_pending_node_data_requests(unsigned src_node, unsigned force)
 	STARPU_PTHREAD_MUTEX_LOCK(&data_requests_pending_list_mutex[src_node]);
 	data_requests_npending[src_node] -= taken - kept;
 	if (kept)
-		_starpu_data_request_list_push_list_back(data_requests_pending[src_node], new_data_requests_pending);
+		_starpu_data_request_list_push_list_back(&data_requests_pending[src_node], &new_data_requests_pending);
 	STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_pending_list_mutex[src_node]);
 
-	_starpu_data_request_list_delete(local_list);
-	_starpu_data_request_list_delete(new_data_requests_pending);
-
 	return taken - kept;
 }
 
@@ -718,9 +696,9 @@ int _starpu_check_that_no_data_request_exists(unsigned node)
 	int no_pending;
 
 	STARPU_PTHREAD_MUTEX_LOCK(&data_requests_list_mutex[node]);
-	no_request = _starpu_data_request_list_empty(data_requests[node])
-	          && _starpu_data_request_list_empty(prefetch_requests[node])
-		  && _starpu_data_request_list_empty(idle_requests[node]);
+	no_request = _starpu_data_request_list_empty(&data_requests[node])
+	          && _starpu_data_request_list_empty(&prefetch_requests[node])
+		  && _starpu_data_request_list_empty(&idle_requests[node]);
 	STARPU_PTHREAD_MUTEX_UNLOCK(&data_requests_list_mutex[node]);
 	STARPU_PTHREAD_MUTEX_LOCK(&data_requests_pending_list_mutex[node]);
 	no_pending = !data_requests_npending[node];
@@ -756,33 +734,33 @@ void _starpu_update_prefetch_status(struct _starpu_data_request *r, unsigned pre
 	/* The request can be in a different list (handling request or the temp list)
 	 * we have to check that it is really in the prefetch list. */
 	struct _starpu_data_request *r_iter;
-	for (r_iter = _starpu_data_request_list_begin(prefetch_requests[r->handling_node]);
-	     r_iter != _starpu_data_request_list_end(prefetch_requests[r->handling_node]);
+	for (r_iter = _starpu_data_request_list_begin(&prefetch_requests[r->handling_node]);
+	     r_iter != _starpu_data_request_list_end(&prefetch_requests[r->handling_node]);
 	     r_iter = _starpu_data_request_list_next(r_iter))
 	{
 
 		if (r==r_iter)
 		{
-			_starpu_data_request_list_erase(prefetch_requests[r->handling_node],r);
-			_starpu_data_request_list_push_front(data_requests[r->handling_node],r);
+			_starpu_data_request_list_erase(&prefetch_requests[r->handling_node],r);
+			_starpu_data_request_list_push_front(&data_requests[r->handling_node],r);
 			goto found;
 		}
 	}
 
 	/* The request can be in a different list (handling request or the temp list)
 	 * we have to check that it is really in the idle list. */
-	for (r_iter = _starpu_data_request_list_begin(idle_requests[r->handling_node]);
-	     r_iter != _starpu_data_request_list_end(idle_requests[r->handling_node]);
+	for (r_iter = _starpu_data_request_list_begin(&idle_requests[r->handling_node]);
+	     r_iter != _starpu_data_request_list_end(&idle_requests[r->handling_node]);
 	     r_iter = _starpu_data_request_list_next(r_iter))
 	{
 
 		if (r==r_iter)
 		{
-			_starpu_data_request_list_erase(idle_requests[r->handling_node],r);
+			_starpu_data_request_list_erase(&idle_requests[r->handling_node],r);
 			if (prefetch == 1)
-				_starpu_data_request_list_push_front(prefetch_requests[r->handling_node],r);
+				_starpu_data_request_list_push_front(&prefetch_requests[r->handling_node],r);
 			else
-				_starpu_data_request_list_push_front(data_requests[r->handling_node],r);
+				_starpu_data_request_list_push_front(&data_requests[r->handling_node],r);
 			goto found;
 		}
 	}

src/datawizard/data_request.h

@@ -15,11 +15,13 @@
  * See the GNU Lesser General Public License in COPYING.LGPL for more details.
  */
 
+/* This one includes us, so make sure to include it first */
+#include <datawizard/coherency.h>
+
 #ifndef __DATA_REQUEST_H__
 #define __DATA_REQUEST_H__
 
 #include <semaphore.h>
-#include <datawizard/coherency.h>
 #include <datawizard/copy_driver.h>
 #include <common/list.h>
 #include <common/starpu_spinlock.h>

src/datawizard/filters.c

@@ -174,8 +174,8 @@ void starpu_data_partition(starpu_data_handle_t initial_handle, struct starpu_da
 		child->is_readonly = initial_handle->is_readonly;
 
 		/* initialize the chunk lock */
-		child->req_list = _starpu_data_requester_list_new();
-		child->reduction_req_list = _starpu_data_requester_list_new();
+		_starpu_data_requester_list_init(&child->req_list);
+		_starpu_data_requester_list_init(&child->reduction_req_list);
 		child->reduction_tmp_handles = NULL;
 		child->refcnt = 0;
 		child->busy_count = 0;
@@ -214,7 +214,7 @@ void starpu_data_partition(starpu_data_handle_t initial_handle, struct starpu_da
 			starpu_data_assign_arbiter(child, _starpu_global_arbiter);
 		else
 			child->arbiter = NULL;
-		child->arbitered_req_list = _starpu_data_requester_list_new();
+		_starpu_data_requester_list_init(&child->arbitered_req_list);
 
 		for (node = 0; node < STARPU_MAXNODES; node++)
 		{
@@ -375,8 +375,6 @@ void starpu_data_unpartition(starpu_data_handle_t root_handle, unsigned gatherin
 		}
 
 		_starpu_memory_stats_free(child_handle);
-		_starpu_data_requester_list_delete(child_handle->req_list);
-		_starpu_data_requester_list_delete(child_handle->reduction_req_list);
 	}
 
 	/* the gathering_node should now have a valid copy of all the children.

src/datawizard/interfaces/bcsr_interface.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2009-2014  Université de Bordeaux
+ * Copyright (C) 2009-2015  Université de Bordeaux
  * Copyright (C) 2010, 2011, 2012, 2013, 2014  CNRS
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -21,6 +21,7 @@
 #include <datawizard/coherency.h>
 #include <datawizard/copy_driver.h>
 #include <datawizard/filters.h>
+#include <datawizard/memory_nodes.h>
 #include <starpu_hash.h>
 
 #include <starpu_cuda.h>

src/datawizard/interfaces/block_interface.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2009-2014  Université de Bordeaux
+ * Copyright (C) 2009-2015  Université de Bordeaux
  * Copyright (C) 2010, 2011, 2012, 2013, 2014  CNRS
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -20,6 +20,7 @@
 #include <datawizard/coherency.h>
 #include <datawizard/copy_driver.h>
 #include <datawizard/filters.h>
+#include <datawizard/memory_nodes.h>
 
 #include <starpu_hash.h>
 

src/datawizard/interfaces/csr_interface.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2009-2014  Université de Bordeaux
+ * Copyright (C) 2009-2015  Université de Bordeaux
  * Copyright (C) 2010  Mehdi Juhoor <mjuhoor@gmail.com>
  * Copyright (C) 2010, 2011, 2012, 2013, 2014  CNRS
  *
@@ -21,6 +21,7 @@
 #include <datawizard/coherency.h>
 #include <datawizard/copy_driver.h>
 #include <datawizard/filters.h>
+#include <datawizard/memory_nodes.h>
 
 #include <starpu_hash.h>
 

src/datawizard/interfaces/data_interface.c

@@ -19,6 +19,7 @@
 #include <stdint.h>
 
 #include <datawizard/datawizard.h>
+#include <datawizard/memory_nodes.h>
 #include <core/dependencies/data_concurrency.h>
 #include <common/uthash.h>
 #include <common/starpu_spinlock.h>
@@ -238,7 +239,7 @@ static void _starpu_register_new_data(starpu_data_handle_t handle,
 	STARPU_ASSERT(handle);
 
 	/* initialize the new lock */
-	handle->req_list = _starpu_data_requester_list_new();
+	_starpu_data_requester_list_init(&handle->req_list);
 	handle->refcnt = 0;
 	handle->busy_count = 0;
 	handle->busy_waiting = 0;
@@ -279,7 +280,7 @@ static void _starpu_register_new_data(starpu_data_handle_t handle,
 	handle->init_cl = NULL;
 
 	handle->reduction_refcnt = 0;
-	handle->reduction_req_list = _starpu_data_requester_list_new();
+	_starpu_data_requester_list_init(&handle->reduction_req_list);
 	handle->reduction_tmp_handles = NULL;
 
 #ifdef STARPU_USE_FXT
@@ -301,7 +302,7 @@ static void _starpu_register_new_data(starpu_data_handle_t handle,
 		starpu_data_assign_arbiter(handle, _starpu_global_arbiter);
 	else
 		handle->arbiter = NULL;
-	handle->arbitered_req_list = _starpu_data_requester_list_new();
+	_starpu_data_requester_list_init(&handle->arbitered_req_list);
 
 	/* that new data is invalid from all nodes perpective except for the
 	 * home node */
@@ -804,9 +805,6 @@ static void _starpu_data_unregister(starpu_data_handle_t handle, unsigned cohere
 	_starpu_data_free_interfaces(handle);
 
 	_starpu_memory_stats_free(handle);
-	_starpu_data_requester_list_delete(handle->arbitered_req_list);
-	_starpu_data_requester_list_delete(handle->req_list);
-	_starpu_data_requester_list_delete(handle->reduction_req_list);
 
 	_starpu_spin_unlock(&handle->header_lock);
 	_starpu_spin_destroy(&handle->header_lock);

src/datawizard/interfaces/matrix_interface.c

@@ -20,6 +20,7 @@
 #include <datawizard/coherency.h>
 #include <datawizard/copy_driver.h>
 #include <datawizard/filters.h>
+#include <datawizard/memory_nodes.h>
 #include <starpu_hash.h>
 #include <starpu_cuda.h>
 #include <starpu_opencl.h>

src/datawizard/interfaces/multiformat_interface.c

@@ -19,6 +19,7 @@
 #include <datawizard/coherency.h>
 #include <datawizard/copy_driver.h>
 #include <datawizard/filters.h>
+#include <datawizard/memory_nodes.h>
 #include <starpu_hash.h>
 #include <starpu_cuda.h>
 #include <starpu_opencl.h>

src/datawizard/interfaces/variable_interface.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010-2014  Université de Bordeaux
+ * Copyright (C) 2010-2015  Université de Bordeaux
  * Copyright (C) 2010, 2011, 2012, 2013, 2014  CNRS
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -20,6 +20,7 @@
 #include <datawizard/coherency.h>
 #include <datawizard/copy_driver.h>
 #include <datawizard/filters.h>
+#include <datawizard/memory_nodes.h>
 #include <starpu_hash.h>
 #include <starpu_cuda.h>
 #include <starpu_opencl.h>

src/datawizard/interfaces/vector_interface.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2009-2014  Université de Bordeaux
+ * Copyright (C) 2009-2015  Université de Bordeaux
  * Copyright (C) 2010, 2011, 2012, 2013, 2014  CNRS
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -20,6 +20,7 @@
 #include <datawizard/coherency.h>
 #include <datawizard/copy_driver.h>
 #include <datawizard/filters.h>
+#include <datawizard/memory_nodes.h>
 #include <starpu_hash.h>
 #include <starpu_cuda.h>
 #include <starpu_opencl.h>

src/datawizard/malloc.c

@@ -676,7 +676,7 @@ LIST_TYPE(_starpu_chunk,
 )
 
 /* One list of chunks per node */
-static struct _starpu_chunk_list *chunks[STARPU_MAXNODES];
+static struct _starpu_chunk_list chunks[STARPU_MAXNODES];
 /* Number of completely free chunks */
 static int nfreechunks[STARPU_MAXNODES];
 /* This protects chunks and nfreechunks */
@@ -685,7 +685,7 @@ static starpu_pthread_mutex_t chunk_mutex[STARPU_MAXNODES];
 void
 _starpu_malloc_init(unsigned dst_node)
 {
-	chunks[dst_node] = _starpu_chunk_list_new();
+	_starpu_chunk_list_init(&chunks[dst_node]);
 	nfreechunks[dst_node] = 0;
 	STARPU_PTHREAD_MUTEX_INIT(&chunk_mutex[dst_node], NULL);
 }
@@ -695,21 +695,16 @@ _starpu_malloc_shutdown(unsigned dst_node)
 {
 	struct _starpu_chunk *chunk, *next_chunk;
 
-	if (!chunks[dst_node])
-		return;
-
 	STARPU_PTHREAD_MUTEX_LOCK(&chunk_mutex[dst_node]);
-	for (chunk = _starpu_chunk_list_begin(chunks[dst_node]);
-	     chunk != _starpu_chunk_list_end(chunks[dst_node]);
+	for (chunk = _starpu_chunk_list_begin(&chunks[dst_node]);
+	     chunk != _starpu_chunk_list_end(&chunks[dst_node]);
 	     chunk = next_chunk)
 	{
 		next_chunk = _starpu_chunk_list_next(chunk);
 		_starpu_free_on_node(dst_node, chunk->base, CHUNK_SIZE);
-		_starpu_chunk_list_erase(chunks[dst_node], chunk);
+		_starpu_chunk_list_erase(&chunks[dst_node], chunk);
 		free(chunk);
 	}
-	_starpu_chunk_list_delete(chunks[dst_node]);
-	chunks[dst_node] = NULL;
 	STARPU_PTHREAD_MUTEX_UNLOCK(&chunk_mutex[dst_node]);
 	STARPU_PTHREAD_MUTEX_DESTROY(&chunk_mutex[dst_node]);
 }
@@ -758,8 +753,8 @@ starpu_malloc_on_node(unsigned dst_node, size_t size)
 	STARPU_PTHREAD_MUTEX_LOCK(&chunk_mutex[dst_node]);
 
 	/* Try to find a big enough segment among the chunks */
-	for (chunk = _starpu_chunk_list_begin(chunks[dst_node]);
-	     chunk != _starpu_chunk_list_end(chunks[dst_node]);
+	for (chunk = _starpu_chunk_list_begin(&chunks[dst_node]);
+	     chunk != _starpu_chunk_list_end(&chunks[dst_node]);
 	     chunk = _starpu_chunk_list_next(chunk))
 	{
 		if (chunk->available_max < nblocks)
@@ -781,8 +776,8 @@ starpu_malloc_on_node(unsigned dst_node, size_t size)
 					/* This one this has quite some room,
 					 * put it front, to make finding it
 					 * easier next time. */
-					_starpu_chunk_list_erase(chunks[dst_node], chunk);
-					_starpu_chunk_list_push_front(chunks[dst_node], chunk);
+					_starpu_chunk_list_erase(&chunks[dst_node], chunk);
+					_starpu_chunk_list_push_front(&chunks[dst_node], chunk);
 				}
 				if (chunk->available == CHUNK_NBLOCKS)
 					/* This one was empty, it's not empty any more */
@@ -809,7 +804,7 @@ starpu_malloc_on_node(unsigned dst_node, size_t size)
 	}
 
 	/* And make it easy to find. */
-	_starpu_chunk_list_push_front(chunks[dst_node], chunk);
+	_starpu_chunk_list_push_front(&chunks[dst_node], chunk);
 	bitmap = chunk->bitmap;
 	prevblock = 0;
 	block = 1;
@@ -854,12 +849,12 @@ starpu_free_on_node(unsigned dst_node, uintptr_t addr, size_t size)
 	int nblocks = (size + CHUNK_ALLOC_MIN - 1) / CHUNK_ALLOC_MIN;
 
 	STARPU_PTHREAD_MUTEX_LOCK(&chunk_mutex[dst_node]);
-	for (chunk = _starpu_chunk_list_begin(chunks[dst_node]);
-	     chunk != _starpu_chunk_list_end(chunks[dst_node]);
+	for (chunk = _starpu_chunk_list_begin(&chunks[dst_node]);
+	     chunk != _starpu_chunk_list_end(&chunks[dst_node]);
 	     chunk = _starpu_chunk_list_next(chunk))
 		if (addr >= chunk->base && addr < chunk->base + CHUNK_SIZE)
 			break;
-	STARPU_ASSERT(chunk != _starpu_chunk_list_end(chunks[dst_node]));
+	STARPU_ASSERT(chunk != _starpu_chunk_list_end(&chunks[dst_node]));
 
 	struct block *bitmap = chunk->bitmap;
 	int block = ((addr - chunk->base) / CHUNK_ALLOC_MIN) + 1, prevblock, nextblock;
@@ -915,7 +910,7 @@ starpu_free_on_node(unsigned dst_node, uintptr_t addr, size_t size)
 		{
 			/* We already have free chunks, release this one */
 			_starpu_free_on_node(dst_node, chunk->base, CHUNK_SIZE);
-			_starpu_chunk_list_erase(chunks[dst_node], chunk);
+			_starpu_chunk_list_erase(&chunks[dst_node], chunk);
 			free(chunk);
 		}
 		else
@@ -924,8 +919,8 @@ starpu_free_on_node(unsigned dst_node, uintptr_t addr, size_t size)
 	else
 	{
 		/* Freed some room, put this first in chunks list */
-		_starpu_chunk_list_erase(chunks[dst_node], chunk);
-		_starpu_chunk_list_push_front(chunks[dst_node], chunk);
+		_starpu_chunk_list_erase(&chunks[dst_node], chunk);
+		_starpu_chunk_list_push_front(&chunks[dst_node], chunk);
 	}
 
 	STARPU_PTHREAD_MUTEX_UNLOCK(&chunk_mutex[dst_node]);

src/datawizard/memalloc.c

@@ -16,6 +16,7 @@
  */
 
 #include <datawizard/memory_manager.h>
+#include <datawizard/memory_nodes.h>
 #include <datawizard/memalloc.h>
 #include <datawizard/footprint.h>
 #include <core/disk.h>
@@ -29,7 +30,7 @@ static struct _starpu_spinlock mc_lock[STARPU_MAXNODES];
 /* Potentially in use memory chunks. The beginning of the list is clean (home
  * node has a copy of the data, or the data is being transferred there), the
  * remainder of the list may not be clean. */
-static struct _starpu_mem_chunk_list *mc_list[STARPU_MAXNODES];
+static struct _starpu_mem_chunk_list mc_list[STARPU_MAXNODES];
 /* This is a shortcut inside the mc_list to the first potentially dirty MC. All
  * MC before this are clean, MC before this only *may* be clean. */
 static struct _starpu_mem_chunk *mc_dirty_head[STARPU_MAXNODES];
@@ -40,7 +41,7 @@ static unsigned mc_nb[STARPU_MAXNODES], mc_clean_nb[STARPU_MAXNODES];
 
 /* TODO: no home doesn't mean always clean, should push to larger memory nodes */
 #define MC_LIST_PUSH_BACK(node, mc) do {				 \
-	_starpu_mem_chunk_list_push_back(mc_list[node], mc);		 \
+	_starpu_mem_chunk_list_push_back(&mc_list[node], mc);		 \
 	if ((mc)->clean || (mc)->home)					 \
 		/* This is clean */					 \
 		mc_clean_nb[node]++;					 \
@@ -53,9 +54,9 @@ static unsigned mc_nb[STARPU_MAXNODES], mc_clean_nb[STARPU_MAXNODES];
 /* Put new clean mc at the end of the clean part of mc_list, i.e. just before mc_dirty_head (if any) */
 #define MC_LIST_PUSH_CLEAN(node, mc) do {				 \
 	if (mc_dirty_head[node])						 \
-		_starpu_mem_chunk_list_insert_before(mc_list[node], mc, mc_dirty_head[node]); \
+		_starpu_mem_chunk_list_insert_before(&mc_list[node], mc, mc_dirty_head[node]); \
 	else								 \
-		_starpu_mem_chunk_list_push_back(mc_list[node], mc);	 \
+		_starpu_mem_chunk_list_push_back(&mc_list[node], mc);	 \
 	/* This is clean */						 \
 	mc_clean_nb[node]++;						 \
 	mc_nb[node]++;							 \
@@ -70,7 +71,7 @@ static unsigned mc_nb[STARPU_MAXNODES], mc_clean_nb[STARPU_MAXNODES];
 	/* One element less */						 \
 	mc_nb[node]--;							 \
 	/* Remove element */						 \
-	_starpu_mem_chunk_list_erase(mc_list[node], (mc));		 \
+	_starpu_mem_chunk_list_erase(&mc_list[node], (mc));		 \
 	/* Notify whoever asked for it */				 \
 	if ((mc)->remove_notify)					 \
 	{								 \
@@ -83,7 +84,7 @@ static unsigned mc_nb[STARPU_MAXNODES], mc_clean_nb[STARPU_MAXNODES];
 struct mc_cache_entry
 {
 	UT_hash_handle hh;
-	struct _starpu_mem_chunk_list *list;
+	struct _starpu_mem_chunk_list list;
 	uint32_t footprint;
 };
 static struct mc_cache_entry *mc_cache[STARPU_MAXNODES];
@@ -105,7 +106,7 @@ void _starpu_init_mem_chunk_lists(void)
 	for (i = 0; i < STARPU_MAXNODES; i++)
 	{
 		_starpu_spin_init(&mc_lock[i]);
-		mc_list[i] = _starpu_mem_chunk_list_new();
+		_starpu_mem_chunk_list_init(&mc_list[i]);
 		STARPU_HG_DISABLE_CHECKING(mc_cache_size[i]);
 		STARPU_HG_DISABLE_CHECKING(mc_nb[i]);
 		STARPU_HG_DISABLE_CHECKING(mc_clean_nb[i]);
@@ -121,11 +122,9 @@ void _starpu_deinit_mem_chunk_lists(void)
 		STARPU_ASSERT(mc_nb[i] == 0);
 		STARPU_ASSERT(mc_clean_nb[i] == 0);
 		STARPU_ASSERT(mc_dirty_head[i] == NULL);
-		_starpu_mem_chunk_list_delete(mc_list[i]);
 		HASH_ITER(hh, mc_cache[i], entry, tmp)
 		{
 			HASH_DEL(mc_cache[i], entry);
-			_starpu_mem_chunk_list_delete(entry->list);
 			free(entry);
 		}
 		STARPU_ASSERT(mc_cache_nb[i] == 0);
@@ -608,8 +607,8 @@ static struct _starpu_mem_chunk *_starpu_memchunk_cache_lookup_locked(unsigned n
 		return NULL;
 
 	struct _starpu_mem_chunk *mc;
-	for (mc = _starpu_mem_chunk_list_begin(entry->list);
-	     mc != _starpu_mem_chunk_list_end(entry->list);
+	for (mc = _starpu_mem_chunk_list_begin(&entry->list);
+	     mc != _starpu_mem_chunk_list_end(&entry->list);
 	     mc = _starpu_mem_chunk_list_next(mc))
 	{
 		/* Is that a false hit ? (this is _very_ unlikely) */
@@ -619,7 +618,7 @@ static struct _starpu_mem_chunk *_starpu_memchunk_cache_lookup_locked(unsigned n
 		/* Cache hit */
 
 		/* Remove from the cache */
-		_starpu_mem_chunk_list_erase(entry->list, mc);
+		_starpu_mem_chunk_list_erase(&entry->list, mc);
 		mc_cache_nb[node]--;
 		STARPU_ASSERT(mc_cache_nb[node] >= 0);
 		mc_cache_size[node] -= mc->size;
@@ -657,8 +656,8 @@ static unsigned try_to_find_reusable_mem_chunk(unsigned node, starpu_data_handle
 
 restart:
 	/* now look for some non essential data in the active list */
-	for (mc = _starpu_mem_chunk_list_begin(mc_list[node]);
-	     mc != _starpu_mem_chunk_list_end(mc_list[node]) && !success;
+	for (mc = _starpu_mem_chunk_list_begin(&mc_list[node]);
+	     mc != _starpu_mem_chunk_list_end(&mc_list[node]) && !success;
 	     mc = next_mc)
 	{
 		/* there is a risk that the memory chunk is freed before next
@@ -716,9 +715,9 @@ static size_t flush_memchunk_cache(unsigned node, size_t reclaim)
 	_starpu_spin_lock(&mc_lock[node]);
 	HASH_ITER(hh, mc_cache[node], entry, tmp)
 	{
-		while (!_starpu_mem_chunk_list_empty(entry->list))
+		while (!_starpu_mem_chunk_list_empty(&entry->list))
 		{
-			mc = _starpu_mem_chunk_list_pop_front(entry->list);
+			mc = _starpu_mem_chunk_list_pop_front(&entry->list);
 			STARPU_ASSERT(!mc->data);
 			STARPU_ASSERT(!mc->replicate);
 
@@ -766,8 +765,8 @@ restart:
 	_starpu_spin_lock(&mc_lock[node]);
 
 restart2:
-	for (mc = _starpu_mem_chunk_list_begin(mc_list[node]);
-	     mc != _starpu_mem_chunk_list_end(mc_list[node]) && (!reclaim || freed < reclaim);
+	for (mc = _starpu_mem_chunk_list_begin(&mc_list[node]);
+	     mc != _starpu_mem_chunk_list_end(&mc_list[node]) && (!reclaim || freed < reclaim);
 	     mc = next_mc)
 	{
 		/* mc hopefully gets out of the list, we thus need to prefetch
@@ -1147,13 +1146,13 @@ void _starpu_request_mem_chunk_removal(starpu_data_handle_t handle, struct _star
 		if (!entry)
 		{
 			entry = malloc(sizeof(*entry));
-			entry->list = _starpu_mem_chunk_list_new();
+			_starpu_mem_chunk_list_init(&entry->list);
 			entry->footprint = footprint;
 			HASH_ADD(hh, mc_cache[node], footprint, sizeof(entry->footprint), entry);
 		}
 		mc_cache_nb[node]++;
 		mc_cache_size[node] += mc->size;
-		_starpu_mem_chunk_list_push_front(entry->list, mc);
+		_starpu_mem_chunk_list_push_front(&entry->list, mc);
 		_starpu_spin_unlock(&mc_lock[node]);
 	}
 }
@@ -1385,15 +1384,15 @@ void _starpu_memory_display_stats_by_node(int node)
 {
 	_starpu_spin_lock(&mc_lock[node]);
 
-	if (!_starpu_mem_chunk_list_empty(mc_list[node]))
+	if (!_starpu_mem_chunk_list_empty(&mc_list[node]))
 	{
 		struct _starpu_mem_chunk *mc;
 
 		fprintf(stderr, "#-------\n");
 		fprintf(stderr, "Data on Node #%d\n",node);
 
-		for (mc = _starpu_mem_chunk_list_begin(mc_list[node]);
-		     mc != _starpu_mem_chunk_list_end(mc_list[node]);
+		for (mc = _starpu_mem_chunk_list_begin(&mc_list[node]);
+		     mc != _starpu_mem_chunk_list_end(&mc_list[node]);
 		     mc = _starpu_mem_chunk_list_next(mc))
 		{
 			if (mc->automatically_allocated == 0)

src/datawizard/memory_nodes.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2009-2014  Université de Bordeaux
+ * Copyright (C) 2009-2015  Université de Bordeaux
  * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015  CNRS
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -19,6 +19,7 @@
 #include <core/sched_policy.h>
 #include <datawizard/datastats.h>
 #include <datawizard/memory_manager.h>
+#include <datawizard/memory_nodes.h>
 #include <common/fxt.h>
 #include "copy_driver.h"
 #include "memalloc.h"

src/debug/traces/starpu_fxt.c

@@ -148,7 +148,7 @@ LIST_TYPE(_starpu_symbol_name,
 	char *name;
 )
 
-static struct _starpu_symbol_name_list *symbol_list;
+static struct _starpu_symbol_name_list symbol_list;
 
 LIST_TYPE(_starpu_communication,
 	unsigned comid;
@@ -158,7 +158,7 @@ LIST_TYPE(_starpu_communication,
 	unsigned dst_node;
 )
 
-static struct _starpu_communication_list *communication_list;
+static struct _starpu_communication_list communication_list;
 
 /*
  * Paje trace file tools
@@ -615,8 +615,8 @@ static void create_paje_state_color(char *name, char *type, float red, float gre
 static void create_paje_state_if_not_found(char *name, struct starpu_fxt_options *options)
 {
 	struct _starpu_symbol_name *itor;
-	for (itor = _starpu_symbol_name_list_begin(symbol_list);
-		itor != _starpu_symbol_name_list_end(symbol_list);
+	for (itor = _starpu_symbol_name_list_begin(&symbol_list);
+		itor != _starpu_symbol_name_list_end(&symbol_list);
 		itor = _starpu_symbol_name_list_next(itor))
 	{
 		if (!strcmp(name, itor->name))
@@ -631,7 +631,7 @@ static void create_paje_state_if_not_found(char *name, struct starpu_fxt_options
 	entry->name = malloc(strlen(name) + 1);
 	strcpy(entry->name, name);
 
-	_starpu_symbol_name_list_push_front(symbol_list, entry);
+	_starpu_symbol_name_list_push_front(&symbol_list, entry);
 
 	/* choose some colour ... that's disguting yes */
 	unsigned hash_symbol_red = get_colour_symbol_red(name);
@@ -1098,7 +1098,7 @@ static void handle_start_driver_copy(struct fxt_ev_64 *ev, struct starpu_fxt_opt
 		com->src_node = src;
 		com->dst_node = dst;
 
-		_starpu_communication_list_push_back(communication_list, com);
+		_starpu_communication_list_push_back(&communication_list, com);
 	}
 
 }
@@ -1166,8 +1166,8 @@ static void handle_end_driver_copy(struct fxt_ev_64 *ev, struct starpu_fxt_optio
 
 		/* look for a data transfer to match */
 		struct _starpu_communication *itor;
-		for (itor = _starpu_communication_list_begin(communication_list);
-			itor != _starpu_communication_list_end(communication_list);
+		for (itor = _starpu_communication_list_begin(&communication_list);
+			itor != _starpu_communication_list_end(&communication_list);
 			itor = _starpu_communication_list_next(itor))
 		{
 			if (itor->comid == comid)
@@ -1185,7 +1185,7 @@ static void handle_end_driver_copy(struct fxt_ev_64 *ev, struct starpu_fxt_optio
 				com->src_node = itor->src_node;
 				com->dst_node = itor->dst_node;
 
-				_starpu_communication_list_push_back(communication_list, com);
+				_starpu_communication_list_push_back(&communication_list, com);
 
 				break;
 			}
@@ -1645,8 +1645,8 @@ void _starpu_fxt_display_bandwidth(struct starpu_fxt_options *options)
 	char *prefix = options->file_prefix;
 
 	struct _starpu_communication*itor;
-	for (itor = _starpu_communication_list_begin(communication_list);
-		itor != _starpu_communication_list_end(communication_list);
+	for (itor = _starpu_communication_list_begin(&communication_list);
+		itor != _starpu_communication_list_end(&communication_list);
 		itor = _starpu_communication_list_next(itor))
 	{
 		current_bandwidth_per_node[itor->src_node] +=  itor->bandwidth;
@@ -1700,8 +1700,8 @@ void _starpu_fxt_parse_new_file(char *filename_in, struct starpu_fxt_options *op
 	fxt_blockev_t block;
 	block = fxt_blockev_enter(fut);
 
-	symbol_list = _starpu_symbol_name_list_new();
-	communication_list = _starpu_communication_list_new();
+	_starpu_symbol_name_list_init(&symbol_list);
+	_starpu_communication_list_init(&communication_list);
 
 	char *prefix = options->file_prefix;
 

src/drivers/cuda/driver_cuda.c

@@ -30,6 +30,7 @@
 #include <cuda_gl_interop.h>
 #endif
 #include <datawizard/memory_manager.h>
+#include <datawizard/memory_nodes.h>
 #include <datawizard/malloc.h>
 
 #ifdef STARPU_SIMGRID

src/drivers/mp_common/mp_common.c

@@ -170,7 +170,7 @@ _starpu_mp_common_node_create(enum _starpu_mp_node_kind node_kind,
 	if (node->init)
 		node->init(node);
 
-	node->message_queue = mp_message_list_new();
+	mp_message_list_init(&node->message_queue);
 	STARPU_PTHREAD_MUTEX_INIT(&node->message_queue_mutex,NULL);
 
 	/* If the node is a sink then we must initialize some field */
@@ -186,7 +186,7 @@ _starpu_mp_common_node_create(enum _starpu_mp_node_kind node_kind,
 			node->run_table[i] = NULL;
 			sem_init(&node->sem_run_table[i],0,0);
 		}
-		node->barrier_list = mp_barrier_list_new();
+		mp_barrier_list_init(&node->barrier_list);
 		STARPU_PTHREAD_MUTEX_INIT(&node->barrier_mutex,NULL);
 
 		STARPU_PTHREAD_BARRIER_INIT(&node->init_completed_barrier, NULL, node->nb_cores+1);
@@ -203,7 +203,6 @@ void _starpu_mp_common_node_destroy(struct _starpu_mp_node *node)
 	if (node->deinit)
 		node->deinit(node);
 		
-	mp_message_list_delete(node->message_queue);
 	STARPU_PTHREAD_MUTEX_DESTROY(&node->message_queue_mutex);
 
 	/* If the node is a sink then we must destroy some field */
@@ -218,8 +217,6 @@ void _starpu_mp_common_node_destroy(struct _starpu_mp_node *node)
 		free(node->run_table);
 		free(node->sem_run_table);
 
-		mp_barrier_list_delete(node->barrier_list);
-
 		STARPU_PTHREAD_MUTEX_DESTROY(&node->barrier_mutex);
 		STARPU_PTHREAD_BARRIER_DESTROY(&node->init_completed_barrier);
 	}

src/drivers/mp_common/mp_common.h

@@ -184,11 +184,11 @@ struct _starpu_mp_node
 	void* thread_table;
 
         /*list where threads add messages to send to the source node */
-        struct mp_message_list* message_queue;
+        struct mp_message_list message_queue;
 	starpu_pthread_mutex_t message_queue_mutex;
 
 	/*list of barrier for combined worker*/
-	struct mp_barrier_list* barrier_list;
+	struct mp_barrier_list barrier_list;
 	starpu_pthread_mutex_t barrier_mutex;
 
 	/*table where worker comme pick task*/

src/drivers/mp_common/sink_common.c

@@ -291,10 +291,10 @@ void _starpu_sink_common_worker(void)
 
 		STARPU_PTHREAD_MUTEX_LOCK(&node->message_queue_mutex);
 		/* If the list is not empty */
-		if(!mp_message_list_empty(node->message_queue))
+		if(!mp_message_list_empty(&node->message_queue))
 		{
 			/* We pop a message and send it to the host */
-			struct mp_message * message = mp_message_list_pop_back(node->message_queue);
+			struct mp_message * message = mp_message_list_pop_back(&node->message_queue);
 			STARPU_PTHREAD_MUTEX_UNLOCK(&node->message_queue_mutex);
 			//_STARPU_DEBUG("telling host that we have finished the task %p sur %d.\n", task->kernel, task->coreid);
 			_starpu_mp_common_send_command(node, message->type,
@@ -324,8 +324,8 @@ static struct mp_barrier * _starpu_sink_common_get_barrier(struct _starpu_mp_nod
 	struct mp_barrier * b = NULL;
 	STARPU_PTHREAD_MUTEX_LOCK(&node->barrier_mutex);
 	/* Search if the barrier already exist */
-	for(b = mp_barrier_list_begin(node->barrier_list);
-			b != mp_barrier_list_end(node->barrier_list) && b->id != cb_workerid;
+	for(b = mp_barrier_list_begin(&node->barrier_list);
+			b != mp_barrier_list_end(&node->barrier_list) && b->id != cb_workerid;
 			b = mp_barrier_list_next(b));
 
 	/* If we found the barrier */
@@ -342,7 +342,7 @@ static struct mp_barrier * _starpu_sink_common_get_barrier(struct _starpu_mp_nod
 		b->id = cb_workerid;
 		STARPU_PTHREAD_BARRIER_INIT(&b->before_work_barrier,NULL,cb_workersize);
 		STARPU_PTHREAD_BARRIER_INIT(&b->after_work_barrier,NULL,cb_workersize);
-		mp_barrier_list_push_back(node->barrier_list,b);
+		mp_barrier_list_push_back(&node->barrier_list,b);
 		STARPU_PTHREAD_MUTEX_UNLOCK(&node->barrier_mutex);
 		return b;
 	}
@@ -354,7 +354,7 @@ static struct mp_barrier * _starpu_sink_common_get_barrier(struct _starpu_mp_nod
 static void _starpu_sink_common_erase_barrier(struct _starpu_mp_node * node, struct mp_barrier *barrier)
 {
 	STARPU_PTHREAD_MUTEX_LOCK(&node->barrier_mutex);
-	mp_barrier_list_erase(node->barrier_list,barrier);
+	mp_barrier_list_erase(&node->barrier_list,barrier);
 	STARPU_PTHREAD_MUTEX_UNLOCK(&node->barrier_mutex);
 }
 
@@ -363,7 +363,7 @@ static void _starpu_sink_common_erase_barrier(struct _starpu_mp_node * node, str
 static void _starpu_sink_common_append_message(struct _starpu_mp_node *node, struct mp_message * message)
 {
 	STARPU_PTHREAD_MUTEX_LOCK(&node->message_queue_mutex);
-	mp_message_list_push_front(node->message_queue,message);
+	mp_message_list_push_front(&node->message_queue,message);
 	STARPU_PTHREAD_MUTEX_UNLOCK(&node->message_queue_mutex);
 
 }

src/drivers/mp_common/source_common.c

@@ -133,10 +133,10 @@ static void _starpu_src_common_handle_stored_async(struct _starpu_mp_node *node)
 {
 	STARPU_PTHREAD_MUTEX_LOCK(&node->message_queue_mutex);
 	/* while the list is not empty */
-	while(!mp_message_list_empty(node->message_queue))
+	while(!mp_message_list_empty(&node->message_queue))
 	{
 		/* We pop a message and handle it */
-		struct mp_message * message = mp_message_list_pop_back(node->message_queue);
+		struct mp_message * message = mp_message_list_pop_back(&node->message_queue);
 		_starpu_src_common_handle_async(node, message->buffer,
 				message->size, message->type);
 		mp_message_delete(message);
@@ -161,7 +161,7 @@ int _starpu_src_common_store_message(struct _starpu_mp_node *node,
 			message->size = arg_size;
 
 			STARPU_PTHREAD_MUTEX_LOCK(&node->message_queue_mutex);
-			mp_message_list_push_front(node->message_queue,message);
+			mp_message_list_push_front(&node->message_queue,message);
 			STARPU_PTHREAD_MUTEX_UNLOCK(&node->message_queue_mutex);
 			return 1;
 			break;

src/drivers/opencl/driver_opencl.c

@@ -29,6 +29,7 @@
 #include "driver_opencl_utils.h"
 #include <common/utils.h>
 #include <datawizard/memory_manager.h>
+#include <datawizard/memory_nodes.h>
 #include <datawizard/malloc.h>
 
 #ifdef STARPU_SIMGRID

src/sched_policies/component_composed.c

@@ -30,14 +30,14 @@ LIST_TYPE(fun_create_component,
 
 struct starpu_sched_component_composed_recipe
 {
-	struct fun_create_component_list * list;
+	struct fun_create_component_list list;
 };
 
 
 struct starpu_sched_component_composed_recipe * starpu_sched_component_composed_recipe_create(void)
 {
 	struct starpu_sched_component_composed_recipe * recipe = malloc(sizeof(*recipe));
-	recipe->list = fun_create_component_list_new();
+	fun_create_component_list_init(&recipe->list);
 	return recipe;
 }
 
@@ -48,7 +48,7 @@ void starpu_sched_component_composed_recipe_add(struct starpu_sched_component_co
 	struct fun_create_component * e = fun_create_component_new();
 	e->create_component = create_component;
 	e->arg = arg;
-	fun_create_component_list_push_back(recipe->list, e);
+	fun_create_component_list_push_back(&recipe->list, e);
 }
 struct starpu_sched_component_composed_recipe * starpu_sched_component_composed_recipe_create_singleton(struct starpu_sched_component *(*create_component)(struct starpu_sched_tree *tree, void * arg),
 										      void * arg)
@@ -61,9 +61,8 @@ void starpu_sched_component_composed_recipe_destroy(struct starpu_sched_componen
 {
 	if(!recipe)
 		return;
-	while(!fun_create_component_list_empty(recipe->list))
-		fun_create_component_delete(fun_create_component_list_pop_back(recipe->list));
-	fun_create_component_list_delete(recipe->list);
+	while(!fun_create_component_list_empty(&recipe->list))
+		fun_create_component_delete(fun_create_component_list_pop_back(&recipe->list));
 	free(recipe);
 }
 
@@ -86,7 +85,7 @@ struct composed_component create_composed_component(struct starpu_sched_tree *tr
 	struct composed_component c;
 	STARPU_ASSERT(recipe);
 
-	struct fun_create_component_list * list = recipe->list;
+	struct fun_create_component_list * list = &recipe->list;
 	struct fun_create_component * i = fun_create_component_list_begin(list);
 	STARPU_ASSERT(i);
 	STARPU_ASSERT(i->create_component);
@@ -206,8 +205,8 @@ void composed_component_deinit_data(struct starpu_sched_component * _component)
 
 struct starpu_sched_component * starpu_sched_component_composed_component_create(struct starpu_sched_tree *tree, struct starpu_sched_component_composed_recipe * recipe)
 {
-	STARPU_ASSERT(!fun_create_component_list_empty(recipe->list));
-	struct fun_create_component_list * l = recipe->list;
+	STARPU_ASSERT(!fun_create_component_list_empty(&recipe->list));
+	struct fun_create_component_list * l = &recipe->list;
 	if(l->_head == l->_tail)
 		return l->_head->create_component(tree, l->_head->arg);
 	struct starpu_sched_component * component = starpu_sched_component_create(tree);

src/sched_policies/deque_queues.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010-2011, 2014  Université de Bordeaux
+ * Copyright (C) 2010-2011, 2014-2015  Université de Bordeaux
  * Copyright (C) 2010, 2011, 2013  CNRS
  * Copyright (C) 2011  Télécom-SudParis
  *
@@ -30,7 +30,7 @@ struct _starpu_deque_jobq *_starpu_create_deque(void)
 	deque = (struct _starpu_deque_jobq *) malloc(sizeof(struct _starpu_deque_jobq));
 
 	/* note that not all mechanisms (eg. the semaphore) have to be used */
-	deque->jobq = _starpu_job_list_new();
+	_starpu_job_list_init(&deque->jobq);
 	deque->njobs = 0;
 	deque->nprocessed = 0;
 
@@ -43,7 +43,6 @@ struct _starpu_deque_jobq *_starpu_create_deque(void)
 
 void _starpu_destroy_deque(struct _starpu_deque_jobq *deque)
 {
-	_starpu_job_list_delete(deque->jobq);
 	free(deque);
 }
 
@@ -67,8 +66,8 @@ struct starpu_task *_starpu_deque_pop_task(struct _starpu_deque_jobq *deque_queu
 	}
 
 	/* TODO find a task that suits workerid */
-	for (j  = _starpu_job_list_begin(deque_queue->jobq);
-	     j != _starpu_job_list_end(deque_queue->jobq);
+	for (j  = _starpu_job_list_begin(&deque_queue->jobq);
+	     j != _starpu_job_list_end(&deque_queue->jobq);
 	     j  = _starpu_job_list_next(j))
 	{
 		unsigned nimpl;
@@ -77,7 +76,7 @@ struct starpu_task *_starpu_deque_pop_task(struct _starpu_deque_jobq *deque_queu
 		if (starpu_worker_can_execute_task_first_impl(workerid, j->task, &nimpl))
 		{
 			j->nimpl = nimpl;
-			j = _starpu_job_list_pop_front(deque_queue->jobq);
+			j = _starpu_job_list_pop_front(&deque_queue->jobq);
 			_STARPU_TRACE_JOB_POP(j, 0);
 			return j->task;
 		}
@@ -100,7 +99,7 @@ struct _starpu_job_list *_starpu_deque_pop_every_task(struct _starpu_deque_jobq
 	else
 	{
 		/* there is a task */
-		old_list = deque_queue->jobq;
+		old_list = &deque_queue->jobq;
 		new_list = _starpu_job_list_new();
 
 		unsigned new_list_size = 0;

src/sched_policies/deque_queues.h

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010-2011  Université de Bordeaux
+ * Copyright (C) 2010-2011, 2015  Université de Bordeaux
  *
  * StarPU is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -25,7 +25,7 @@
 struct _starpu_deque_jobq
 {
 	/* the actual list */
-	struct _starpu_job_list *jobq;
+	struct _starpu_job_list jobq;
 
 	/* the number of tasks currently in the queue */
 	unsigned njobs;

src/sched_policies/stack_queues.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010-2014  Université de Bordeaux
+ * Copyright (C) 2010-2015  Université de Bordeaux
  * Copyright (C) 2010, 2011, 2013  CNRS
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -37,7 +37,7 @@ struct _starpu_stack_jobq *_starpu_create_stack(void)
 	struct _starpu_stack_jobq *stack;
 	stack = (struct _starpu_stack_jobq *) malloc(sizeof(struct _starpu_stack_jobq));
 
-	stack->jobq = _starpu_job_list_new();
+	_starpu_job_list_init(&stack->jobq);
 	stack->njobs = 0;
 	stack->nprocessed = 0;
 
@@ -64,9 +64,9 @@ void _starpu_stack_push_task(struct _starpu_stack_jobq *stack_queue, starpu_pthr
 	total_number_of_jobs++;
 
 	if (task->task->priority)
-		_starpu_job_list_push_back(stack_queue->jobq, task);
+		_starpu_job_list_push_back(&stack_queue->jobq, task);
 	else
-		_starpu_job_list_push_front(stack_queue->jobq, task);
+		_starpu_job_list_push_front(&stack_queue->jobq, task);
 	stack_queue->njobs++;
 	stack_queue->nprocessed++;
 
@@ -87,7 +87,7 @@ struct _starpu_job *_starpu_stack_pop_task(struct _starpu_stack_jobq *stack_queu
 	if (stack_queue->njobs > 0)
 	{
 		/* there is a task */
-		j = _starpu_job_list_pop_back(stack_queue->jobq);
+		j = _starpu_job_list_pop_back(&stack_queue->jobq);
 
 		STARPU_ASSERT(j);
 		stack_queue->njobs--;

src/sched_policies/stack_queues.h

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010-2011  Université de Bordeaux
+ * Copyright (C) 2010-2011, 2015  Université de Bordeaux
  *
  * StarPU is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -25,7 +25,7 @@
 struct _starpu_stack_jobq
 {
 	/* the actual list */
-	struct _starpu_job_list *jobq;
+	struct _starpu_job_list jobq;
 
 	/* the number of tasks currently in the queue */
 	unsigned njobs;

src/sched_policies/work_stealing_policy.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010-2014  Université de Bordeaux
+ * Copyright (C) 2010-2015  Université de Bordeaux
  * Copyright (C) 2010, 2011, 2012, 2013  CNRS
  * Copyright (C) 2011, 2012  INRIA
  *
@@ -369,7 +369,7 @@ int ws_push_task(struct starpu_task *task)
 		AYU_event(AYU_ADDTASKTOQUEUE, j->job_id, &id);
 	}
 #endif
-	_starpu_job_list_push_back(deque_queue->jobq, j);
+	_starpu_job_list_push_back(&deque_queue->jobq, j);
 	deque_queue->njobs++;
 	starpu_push_task_end(task);
 

src/util/openmp_runtime_support.c

@@ -281,8 +281,8 @@ static struct starpu_omp_region *create_omp_region_struct(struct starpu_omp_regi
 	memset(region, 0, sizeof(*region));
 	region->parent_region = parent_region;
 	region->owner_device = owner_device;
-	region->thread_list = starpu_omp_thread_list_new();
-	region->implicit_task_list = starpu_omp_task_list_new();
+	starpu_omp_thread_list_init(&region->thread_list);
+	starpu_omp_task_list_init(&region->implicit_task_list);
 
 	_starpu_spin_init(&region->lock);
 	_starpu_spin_init(&region->registered_handles_lock);
@@ -293,11 +293,9 @@ static struct starpu_omp_region *create_omp_region_struct(struct starpu_omp_regi
 static void destroy_omp_region_struct(struct starpu_omp_region *region)
 {
 	STARPU_ASSERT(region->nb_threads == 0);
-	STARPU_ASSERT(starpu_omp_thread_list_empty(region->thread_list));
-	STARPU_ASSERT(starpu_omp_task_list_empty(region->implicit_task_list));
+	STARPU_ASSERT(starpu_omp_thread_list_empty(&region->thread_list));
+	STARPU_ASSERT(starpu_omp_task_list_empty(&region->implicit_task_list));
 	STARPU_ASSERT(region->continuation_starpu_task == NULL);
-	starpu_omp_thread_list_delete(region->thread_list);
-	starpu_omp_task_list_delete(region->implicit_task_list);
 	_starpu_spin_destroy(&region->registered_handles_lock);
 	_starpu_spin_destroy(&region->lock);
 	memset(region, 0, sizeof(*region));
@@ -836,7 +834,7 @@ static void omp_initial_region_setup(void)
 	_global_state.initial_region->icvs.run_sched_var = _starpu_omp_initial_icv_values->run_sched_var;
 	_global_state.initial_region->icvs.run_sched_chunk_var = _starpu_omp_initial_icv_values->run_sched_chunk_var;
 	_global_state.initial_region->icvs.default_device_var = _starpu_omp_initial_icv_values->default_device_var;
-	starpu_omp_task_list_push_back(_global_state.initial_region->implicit_task_list,
+	starpu_omp_task_list_push_back(&_global_state.initial_region->implicit_task_list,
 			_global_state.initial_task);
 }
 
@@ -844,7 +842,7 @@ static void omp_initial_region_exit(void)
 {
 	omp_initial_thread_exit();
 	_global_state.initial_task->state = starpu_omp_task_state_terminated;
-	starpu_omp_task_list_pop_front(_global_state.initial_region->implicit_task_list);
+	starpu_omp_task_list_pop_front(&_global_state.initial_region->implicit_task_list);
 	_global_state.initial_region->master_thread = NULL;
 	free(_global_state.initial_region->icvs.nthreads_var);
 	free(_global_state.initial_region->icvs.bind_var);
@@ -1084,13 +1082,13 @@ void starpu_omp_parallel_region(const struct starpu_omp_parallel_region_attr *at
 			{
 				new_thread = master_thread;
 			}
-			starpu_omp_thread_list_push_back(new_region->thread_list, new_thread);
+			starpu_omp_thread_list_push_back(&new_region->thread_list, new_thread);
 		}
 
 		struct starpu_omp_task *new_task = create_omp_task_struct(task, new_thread, new_region, 1);
 		new_task->rank = new_region->nb_threads;
 		new_region->nb_threads++;
-		starpu_omp_task_list_push_back(new_region->implicit_task_list, new_task);
+		starpu_omp_task_list_push_back(&new_region->implicit_task_list, new_task);
 
 	}
 	STARPU_ASSERT(new_region->nb_threads == nb_threads);
@@ -1124,8 +1122,8 @@ void starpu_omp_parallel_region(const struct starpu_omp_parallel_region_attr *at
 	 * create explicit dependencies between these starpu tasks and the continuation starpu task
 	 */
 	struct starpu_omp_task * implicit_task;
-	for (implicit_task  = starpu_omp_task_list_begin(new_region->implicit_task_list);
-			implicit_task != starpu_omp_task_list_end(new_region->implicit_task_list);
+	for (implicit_task  = starpu_omp_task_list_begin(&new_region->implicit_task_list);
+			implicit_task != starpu_omp_task_list_end(&new_region->implicit_task_list);
 			implicit_task  = starpu_omp_task_list_next(implicit_task))
 	{
 		implicit_task->cl = attr->cl;
@@ -1164,8 +1162,8 @@ void starpu_omp_parallel_region(const struct starpu_omp_parallel_region_attr *at
 	/*
 	 * submit all the region implicit starpu tasks
 	 */
-	for (implicit_task  = starpu_omp_task_list_begin(new_region->implicit_task_list);
-			implicit_task != starpu_omp_task_list_end(new_region->implicit_task_list);
+	for (implicit_task  = starpu_omp_task_list_begin(&new_region->implicit_task_list);
+			implicit_task != starpu_omp_task_list_end(&new_region->implicit_task_list);
 			implicit_task  = starpu_omp_task_list_next(implicit_task))
 	{
 		ret = starpu_task_submit(implicit_task->starpu_task);
@@ -1205,11 +1203,11 @@ void starpu_omp_parallel_region(const struct starpu_omp_parallel_region_attr *at
 		}
 		else
 		{
-			starpu_omp_thread_list_pop_front(new_region->thread_list);
+			starpu_omp_thread_list_pop_front(&new_region->thread_list);
 			/* TODO: cleanup unused threads */
 		}
 		new_region->nb_threads--;
-		struct starpu_omp_task *implicit_task = starpu_omp_task_list_pop_front(new_region->implicit_task_list);
+		struct starpu_omp_task *implicit_task = starpu_omp_task_list_pop_front(&new_region->implicit_task_list);
 		destroy_omp_task_struct(implicit_task);
 	}
 	STARPU_ASSERT(new_region->nb_threads == 0);
@@ -1223,8 +1221,8 @@ static void wake_up_barrier(struct starpu_omp_region *parallel_region)
 {
 	struct starpu_omp_task *task = STARPU_PTHREAD_GETSPECIFIC(omp_task_key);
 	struct starpu_omp_task *implicit_task;
-	for (implicit_task  = starpu_omp_task_list_begin(parallel_region->implicit_task_list);
-			implicit_task != starpu_omp_task_list_end(parallel_region->implicit_task_list);
+	for (implicit_task  = starpu_omp_task_list_begin(&parallel_region->implicit_task_list);
+			implicit_task != starpu_omp_task_list_end(&parallel_region->implicit_task_list);
 			implicit_task  = starpu_omp_task_list_next(implicit_task))
 	{
 		if (implicit_task == task)

src/util/openmp_runtime_support.h

@@ -327,9 +327,9 @@ struct starpu_omp_region
 	struct starpu_omp_device *owner_device;
 	struct starpu_omp_thread *master_thread;
 	/* note: the list of threads does not include the master_thread */
-	struct starpu_omp_thread_list *thread_list;
+	struct starpu_omp_thread_list thread_list;
 	/* list of implicit omp tasks created to run the region */
-	struct starpu_omp_task_list *implicit_task_list;
+	struct starpu_omp_task_list implicit_task_list;
 	/* include both the master thread and the region own threads */
 	int nb_threads;
 	struct _starpu_spinlock lock;

src/util/openmp_runtime_support_omp_api.c

@@ -50,8 +50,8 @@ static int _starpu_omp_get_region_thread_num(const struct starpu_omp_region * co
 		return 0;
 	struct starpu_omp_thread * region_thread;
 	int tid = 1;
-	for (region_thread  = starpu_omp_thread_list_begin(region->thread_list);
-			region_thread != starpu_omp_thread_list_end(region->thread_list);
+	for (region_thread  = starpu_omp_thread_list_begin(&region->thread_list);
+			region_thread != starpu_omp_thread_list_end(&region->thread_list);
 			region_thread  = starpu_omp_thread_list_next(region_thread))
 	{
 		if (thread == region_thread)