Prefixing of src/common/starpu-spinlock.h

find . -type f -not -name "*svn*"|xargs sed -i s/"\bstarpu_spin_init\b"/_starpu_spin_init/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bstarpu_spin_destroy\b"/_starpu_spin_destroy/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bstarpu_spin_lock\b"/_starpu_spin_lock/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bstarpu_spin_trylock\b"/_starpu_spin_trylock/g
find . -type f -not -name "*svn*"|xargs sed -i s/"\bstarpu_spin_unlock\b"/_starpu_spin_unlock/g

src/common/starpu-spinlock.c

@@ -18,7 +18,7 @@
 #include <common/config.h>
 #include <starpu-util.h>
 
-int starpu_spin_init(starpu_spinlock_t *lock)
+int _starpu_spin_init(starpu_spinlock_t *lock)
 {
 #ifdef HAVE_PTHREAD_SPIN_LOCK
 	return pthread_spin_init(&lock->lock, 0);
@@ -28,7 +28,7 @@ int starpu_spin_init(starpu_spinlock_t *lock)
 #endif
 }
 
-int starpu_spin_destroy(starpu_spinlock_t *lock)
+int _starpu_spin_destroy(starpu_spinlock_t *lock)
 {
 #ifdef HAVE_PTHREAD_SPIN_LOCK
 	return pthread_spin_destroy(&lock->lock);
@@ -38,7 +38,7 @@ int starpu_spin_destroy(starpu_spinlock_t *lock)
 #endif
 }
 
-int starpu_spin_lock(starpu_spinlock_t *lock)
+int _starpu_spin_lock(starpu_spinlock_t *lock)
 {
 #ifdef HAVE_PTHREAD_SPIN_LOCK
 	return pthread_spin_lock(&lock->lock);
@@ -51,7 +51,7 @@ int starpu_spin_lock(starpu_spinlock_t *lock)
 #endif
 }
 
-int starpu_spin_trylock(starpu_spinlock_t *lock)
+int _starpu_spin_trylock(starpu_spinlock_t *lock)
 {
 #ifdef HAVE_PTHREAD_SPIN_LOCK
 	return pthread_spin_trylock(&lock->lock);
@@ -62,7 +62,7 @@ int starpu_spin_trylock(starpu_spinlock_t *lock)
 #endif
 }
 
-int starpu_spin_unlock(starpu_spinlock_t *lock)
+int _starpu_spin_unlock(starpu_spinlock_t *lock)
 {
 #ifdef HAVE_PTHREAD_SPIN_LOCK
 	return pthread_spin_unlock(&lock->lock);

src/common/starpu-spinlock.h

@@ -30,11 +30,11 @@ typedef struct starpu_spinlock_s {
 #endif
 } starpu_spinlock_t;
 
-int starpu_spin_init(starpu_spinlock_t *lock);
-int starpu_spin_destroy(starpu_spinlock_t *lock);
+int _starpu_spin_init(starpu_spinlock_t *lock);
+int _starpu_spin_destroy(starpu_spinlock_t *lock);
 
-int starpu_spin_lock(starpu_spinlock_t *lock);
-int starpu_spin_trylock(starpu_spinlock_t *lock);
-int starpu_spin_unlock(starpu_spinlock_t *lock);
+int _starpu_spin_lock(starpu_spinlock_t *lock);
+int _starpu_spin_trylock(starpu_spinlock_t *lock);
+int _starpu_spin_unlock(starpu_spinlock_t *lock);
 
 #endif // __STARPU_SPINLOCK_H__

src/core/dependencies/cg.c

@@ -153,7 +153,7 @@ void _starpu_notify_cg_list(struct starpu_cg_list_s *successors)
 		unsigned cg_type = cg->cg_type;
 
 		if (cg_type == STARPU_CG_TAG)
-			starpu_spin_lock(&cgtag->lock);
+			_starpu_spin_lock(&cgtag->lock);
 
 		_starpu_notify_cg(cg);
 		if (cg_type == STARPU_CG_APPS) {
@@ -165,6 +165,6 @@ void _starpu_notify_cg_list(struct starpu_cg_list_s *successors)
 		}
 
 		if (cg_type == STARPU_CG_TAG)
-			starpu_spin_unlock(&cgtag->lock);
+			_starpu_spin_unlock(&cgtag->lock);
 	}
 }

src/core/dependencies/data-concurrency.c

@@ -66,7 +66,7 @@ unsigned _starpu_attempt_to_submit_data_request_from_apps(starpu_data_handle han
 {
 	unsigned ret;
 
-	starpu_spin_lock(&handle->header_lock);
+	_starpu_spin_lock(&handle->header_lock);
 
 	if (handle->refcnt == 0)
 	{
@@ -106,7 +106,7 @@ unsigned _starpu_attempt_to_submit_data_request_from_apps(starpu_data_handle han
 		}
 	}
 
-	starpu_spin_unlock(&handle->header_lock);
+	_starpu_spin_unlock(&handle->header_lock);
 	return ret;
 }
 
@@ -117,7 +117,7 @@ static unsigned attempt_to_submit_data_request_from_job(starpu_job_t j, unsigned
 	starpu_data_handle handle = j->task->buffers[buffer_index].handle;
 	starpu_access_mode mode = j->task->buffers[buffer_index].mode;
 
-	while (starpu_spin_trylock(&handle->header_lock))
+	while (_starpu_spin_trylock(&handle->header_lock))
 		_starpu_datawizard_progress(_starpu_get_local_memory_node(), 0);
 
 	if (handle->refcnt == 0)
@@ -158,7 +158,7 @@ static unsigned attempt_to_submit_data_request_from_job(starpu_job_t j, unsigned
 		}
 	}
 
-	starpu_spin_unlock(&handle->header_lock);
+	_starpu_spin_unlock(&handle->header_lock);
 	return ret;
 }
 
@@ -206,7 +206,7 @@ void _starpu_notify_data_dependencies(starpu_data_handle handle)
 		/* the data is now attributed to that request */
 		handle->current_mode = (r->mode==STARPU_R)?STARPU_R:STARPU_W;
 
-		starpu_spin_unlock(&handle->header_lock);
+		_starpu_spin_unlock(&handle->header_lock);
 
 		if (r->is_requested_by_codelet)
 		{
@@ -223,6 +223,6 @@ void _starpu_notify_data_dependencies(starpu_data_handle handle)
 
 		starpu_data_requester_delete(r);
 		
-		starpu_spin_lock(&handle->header_lock);
+		_starpu_spin_lock(&handle->header_lock);
 	}
 }

src/core/dependencies/tags.c

@@ -72,7 +72,7 @@ static struct starpu_tag_s *_starpu_tag_init(starpu_tag_t id)
 
 	_starpu_cg_list_init(&tag->tag_successors);
 
-	starpu_spin_init(&tag->lock);
+	_starpu_spin_init(&tag->lock);
 
 	return tag;
 }
@@ -88,7 +88,7 @@ void starpu_tag_remove(starpu_tag_t id)
 	pthread_rwlock_unlock(&tag_global_rwlock);
 
 	if (tag) {
-		starpu_spin_lock(&tag->lock);
+		_starpu_spin_lock(&tag->lock);
 
 		unsigned nsuccs = tag->tag_successors.nsuccs;
 		unsigned succ;
@@ -109,7 +109,7 @@ void starpu_tag_remove(starpu_tag_t id)
 		free(tag->tag_successors.succ);
 #endif
 
-		starpu_spin_unlock(&tag->lock);
+		_starpu_spin_unlock(&tag->lock);
 	}
 
 	free(tag);
@@ -150,12 +150,12 @@ void _starpu_tag_set_ready(struct starpu_tag_s *tag)
 	 * the task is "empty", calling _starpu_push_task would directly try to enforce
 	 * the dependencies of the task, and therefore it would try to grab the
 	 * lock again, resulting in a deadlock. */
-	starpu_spin_unlock(&tag->lock);
+	_starpu_spin_unlock(&tag->lock);
 
 	/* enforce data dependencies */
 	_starpu_enforce_deps_starting_from_task(j);
 
-	starpu_spin_lock(&tag->lock);
+	_starpu_spin_lock(&tag->lock);
 }
 
 /* the lock must be taken ! */
@@ -173,14 +173,14 @@ static void _starpu_tag_add_succ(struct starpu_tag_s *tag, starpu_cg_t *cg)
 
 static void _starpu_notify_tag_dependencies(struct starpu_tag_s *tag)
 {
-	starpu_spin_lock(&tag->lock);
+	_starpu_spin_lock(&tag->lock);
 
 	tag->state = STARPU_DONE;
 	TRACE_TASK_DONE(tag);
 
 	_starpu_notify_cg_list(&tag->tag_successors);
 
-	starpu_spin_unlock(&tag->lock);
+	_starpu_spin_unlock(&tag->lock);
 }
 
 void _starpu_notify_dependencies(struct starpu_job_s *j)
@@ -215,9 +215,9 @@ void _starpu_tag_declare(starpu_tag_t id, struct starpu_job_s *job)
 	job->tag = tag;
 
 	/* the tag is now associated to a job */
-	starpu_spin_lock(&tag->lock);
+	_starpu_spin_lock(&tag->lock);
 	tag->state = STARPU_ASSOCIATED;
-	starpu_spin_unlock(&tag->lock);
+	_starpu_spin_unlock(&tag->lock);
 }
 
 void starpu_tag_declare_deps_array(starpu_tag_t id, unsigned ndeps, starpu_tag_t *array)
@@ -227,7 +227,7 @@ void starpu_tag_declare_deps_array(starpu_tag_t id, unsigned ndeps, starpu_tag_t
 	/* create the associated completion group */
 	struct starpu_tag_s *tag_child = gettag_struct(id);
 
-	starpu_spin_lock(&tag_child->lock);
+	_starpu_spin_lock(&tag_child->lock);
 
 	starpu_cg_t *cg = create_cg_tag(ndeps, tag_child);
 
@@ -241,12 +241,12 @@ void starpu_tag_declare_deps_array(starpu_tag_t id, unsigned ndeps, starpu_tag_t
 		 * so cg should be among dep_id's successors*/
 		TRACE_CODELET_TAG_DEPS(id, dep_id);
 		struct starpu_tag_s *tag_dep = gettag_struct(dep_id);
-		starpu_spin_lock(&tag_dep->lock);
+		_starpu_spin_lock(&tag_dep->lock);
 		_starpu_tag_add_succ(tag_dep, cg);
-		starpu_spin_unlock(&tag_dep->lock);
+		_starpu_spin_unlock(&tag_dep->lock);
 	}
 
-	starpu_spin_unlock(&tag_child->lock);
+	_starpu_spin_unlock(&tag_child->lock);
 }
 
 void _starpu_tag_declare_deps(starpu_tag_t id, unsigned ndeps, ...)
@@ -256,7 +256,7 @@ void _starpu_tag_declare_deps(starpu_tag_t id, unsigned ndeps, ...)
 	/* create the associated completion group */
 	struct starpu_tag_s *tag_child = gettag_struct(id);
 
-	starpu_spin_lock(&tag_child->lock);
+	_starpu_spin_lock(&tag_child->lock);
 
 	starpu_cg_t *cg = create_cg_tag(ndeps, tag_child);
 
@@ -273,13 +273,13 @@ void _starpu_tag_declare_deps(starpu_tag_t id, unsigned ndeps, ...)
 		 * so cg should be among dep_id's successors*/
 		TRACE_CODELET_TAG_DEPS(id, dep_id);
 		struct starpu_tag_s *tag_dep = gettag_struct(dep_id);
-		starpu_spin_lock(&tag_dep->lock);
+		_starpu_spin_lock(&tag_dep->lock);
 		_starpu_tag_add_succ(tag_dep, cg);
-		starpu_spin_unlock(&tag_dep->lock);
+		_starpu_spin_unlock(&tag_dep->lock);
 	}
 	va_end(pa);
 
-	starpu_spin_unlock(&tag_child->lock);
+	_starpu_spin_unlock(&tag_child->lock);
 }
 
 /* this function may be called by the application (outside callbacks !) */
@@ -299,12 +299,12 @@ int starpu_tag_wait_array(unsigned ntags, starpu_tag_t *id)
 	{
 		struct starpu_tag_s *tag = gettag_struct(id[i]);
 		
-		starpu_spin_lock(&tag->lock);
+		_starpu_spin_lock(&tag->lock);
 
 		if (tag->state == STARPU_DONE)
 		{
 			/* that tag is done already */
-			starpu_spin_unlock(&tag->lock);
+			_starpu_spin_unlock(&tag->lock);
 		}
 		else
 		{
@@ -325,7 +325,7 @@ int starpu_tag_wait_array(unsigned ntags, starpu_tag_t *id)
 	for (i = 0; i < current; i++)
 	{
 		_starpu_tag_add_succ(tag_array[i], cg);
-		starpu_spin_unlock(&tag_array[i]->lock);
+		_starpu_spin_unlock(&tag_array[i]->lock);
 	}
 
 	pthread_mutex_lock(&cg->succ.succ_apps.cg_mutex);

src/core/jobs.c

@@ -166,7 +166,7 @@ static unsigned _starpu_not_all_tag_deps_are_fulfilled(starpu_job_t j)
 
 	struct starpu_cg_list_s *tag_successors = &tag->tag_successors;
 
-	starpu_spin_lock(&tag->lock);
+	_starpu_spin_lock(&tag->lock);
 
 	if (tag_successors->ndeps != tag_successors->ndeps_completed)
 	{
@@ -181,7 +181,7 @@ static unsigned _starpu_not_all_tag_deps_are_fulfilled(starpu_job_t j)
 		ret = 0;
 	}
 
-	starpu_spin_unlock(&tag->lock);
+	_starpu_spin_unlock(&tag->lock);
 	return ret;
 }
 

src/datawizard/coherency.c

@@ -143,7 +143,7 @@ int _starpu_fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_no
 {
 	uint32_t local_node = _starpu_get_local_memory_node();
 
-	while (starpu_spin_trylock(&handle->header_lock))
+	while (_starpu_spin_trylock(&handle->header_lock))
 		_starpu_datawizard_progress(local_node, 1);
 
 	if (!is_prefetch)
@@ -154,7 +154,7 @@ int _starpu_fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_no
 		/* the data is already available so we can stop */
 		_starpu_update_data_state(handle, requesting_node, write);
 		_starpu_msi_cache_hit(requesting_node);
-		starpu_spin_unlock(&handle->header_lock);
+		_starpu_spin_unlock(&handle->header_lock);
 		return 0;
 	}
 
@@ -210,9 +210,9 @@ int _starpu_fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_no
 			r_src_to_ram->next_req[r_src_to_ram->next_req_count++]= r_ram_to_dst;
 
 			if (reuse_r_src_to_ram)
-				starpu_spin_unlock(&r_src_to_ram->lock);
+				_starpu_spin_unlock(&r_src_to_ram->lock);
 
-			starpu_spin_unlock(&handle->header_lock);
+			_starpu_spin_unlock(&handle->header_lock);
 
 			/* we only submit the first request, the remaining will be automatically submitted afterward */
 			if (!reuse_r_src_to_ram)
@@ -231,7 +231,7 @@ int _starpu_fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_no
 			if (!is_prefetch)
 				r->refcnt++;
 
-			starpu_spin_unlock(&handle->header_lock);
+			_starpu_spin_unlock(&handle->header_lock);
 
 			_starpu_post_data_request(r, handling_node);
 		}
@@ -242,15 +242,15 @@ int _starpu_fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_no
 		/* there is already a similar request */
 		if (is_prefetch)
 		{
-			starpu_spin_unlock(&r->lock);
+			_starpu_spin_unlock(&r->lock);
 
-			starpu_spin_unlock(&handle->header_lock);
+			_starpu_spin_unlock(&handle->header_lock);
 			return 0;
 		}
 
 		r->refcnt++;
 
-		//starpu_spin_lock(&r->lock);
+		//_starpu_spin_lock(&r->lock);
 		if (r->is_a_prefetch_request)
 		{
 			/* transform that prefetch request into a "normal" request */
@@ -262,8 +262,8 @@ int _starpu_fetch_data_on_node(starpu_data_handle handle, uint32_t requesting_no
 		}
 
 		//fprintf(stderr, "found a similar request : refcnt (req) %d\n", r->refcnt);
-		starpu_spin_unlock(&r->lock);
-		starpu_spin_unlock(&handle->header_lock);
+		_starpu_spin_unlock(&r->lock);
+		_starpu_spin_unlock(&handle->header_lock);
 	}
 
 	return (is_prefetch?0:_starpu_wait_data_request_completion(r, 1));
@@ -307,14 +307,14 @@ void _starpu_release_data_on_node(starpu_data_handle handle, uint32_t default_wb
 	}
 
 	uint32_t local_node = _starpu_get_local_memory_node();
-	while (starpu_spin_trylock(&handle->header_lock))
+	while (_starpu_spin_trylock(&handle->header_lock))
 		_starpu_datawizard_progress(local_node, 1);
 
 	handle->per_node[memory_node].refcnt--;
 
 	_starpu_notify_data_dependencies(handle);
 
-	starpu_spin_unlock(&handle->header_lock);
+	_starpu_spin_unlock(&handle->header_lock);
 }
 
 int _starpu_prefetch_task_input_on_node(struct starpu_task *task, uint32_t node)

src/datawizard/data_request.c

@@ -71,7 +71,7 @@ starpu_data_request_t _starpu_create_data_request(starpu_data_handle handle, uin
 {
 	starpu_data_request_t r = starpu_data_request_new();
 
-	starpu_spin_init(&r->lock);
+	_starpu_spin_init(&r->lock);
 
 	r->handle = handle;
 	r->src_node = src_node;
@@ -92,7 +92,7 @@ starpu_data_request_t _starpu_create_data_request(starpu_data_handle handle, uin
 	/* associate that request with the handle so that further similar
 	 * requests will reuse that one  */
 
-	starpu_spin_lock(&r->lock);
+	_starpu_spin_lock(&r->lock);
 
 	handle->per_node[dst_node].request = r;
 
@@ -103,7 +103,7 @@ starpu_data_request_t _starpu_create_data_request(starpu_data_handle handle, uin
 
 	r->refcnt = 1;
 
-	starpu_spin_unlock(&r->lock);
+	_starpu_spin_unlock(&r->lock);
 
 	return r;
 }
@@ -130,7 +130,7 @@ starpu_data_request_t _starpu_search_existing_data_request(starpu_data_handle ha
 		if (write)
 			r->write = 1;
 
-		starpu_spin_lock(&r->lock);
+		_starpu_spin_lock(&r->lock);
 	}
 
 	return r;
@@ -144,12 +144,12 @@ int _starpu_wait_data_request_completion(starpu_data_request_t r, unsigned may_a
 	uint32_t local_node = _starpu_get_local_memory_node();
 
 	do {
-		starpu_spin_lock(&r->lock);
+		_starpu_spin_lock(&r->lock);
 
 		if (r->completed)
 			break;
 
-		starpu_spin_unlock(&r->lock);
+		_starpu_spin_unlock(&r->lock);
 
 		_starpu_wake_all_blocked_workers_on_node(r->handling_node);
 
@@ -169,7 +169,7 @@ int _starpu_wait_data_request_completion(starpu_data_request_t r, unsigned may_a
 	if (r->refcnt == 0)
 		do_delete = 1;
 
-	starpu_spin_unlock(&r->lock);
+	_starpu_spin_unlock(&r->lock);
 	
 	if (do_delete)
 		starpu_data_request_destroy(r);
@@ -237,12 +237,12 @@ static void starpu_handle_data_request_completion(starpu_data_request_t r)
 	
 	r->retval = 0;
 
-	starpu_spin_unlock(&r->lock);
+	_starpu_spin_unlock(&r->lock);
 
 	if (do_delete)
 		starpu_data_request_destroy(r);
 
-	starpu_spin_unlock(&handle->header_lock);
+	_starpu_spin_unlock(&handle->header_lock);
 }
 
 /* TODO : accounting to see how much time was spent working for other people ... */
@@ -250,9 +250,9 @@ static int starpu_handle_data_request(starpu_data_request_t r, unsigned may_allo
 {
 	starpu_data_handle handle = r->handle;
 
-	starpu_spin_lock(&handle->header_lock);
+	_starpu_spin_lock(&handle->header_lock);
 
-	starpu_spin_lock(&r->lock);
+	_starpu_spin_lock(&r->lock);
 
 	if (r->read)
 	{
@@ -266,16 +266,16 @@ static int starpu_handle_data_request(starpu_data_request_t r, unsigned may_allo
 
 	if (r->retval == ENOMEM)
 	{
-		starpu_spin_unlock(&r->lock);
-		starpu_spin_unlock(&handle->header_lock);
+		_starpu_spin_unlock(&r->lock);
+		_starpu_spin_unlock(&handle->header_lock);
 
 		return ENOMEM;
 	}
 
 	if (r->retval == EAGAIN)
 	{
-		starpu_spin_unlock(&r->lock);
-		starpu_spin_unlock(&handle->header_lock);
+		_starpu_spin_unlock(&r->lock);
+		_starpu_spin_unlock(&handle->header_lock);
 
 		/* the request is pending and we put it in the corresponding queue  */
 		pthread_mutex_lock(&data_requests_pending_list_mutex[r->handling_node]);
@@ -364,9 +364,9 @@ static void _handle_pending_node_data_requests(uint32_t src_node, unsigned force
 
 		starpu_data_handle handle = r->handle;
 		
-		starpu_spin_lock(&handle->header_lock);
+		_starpu_spin_lock(&handle->header_lock);
 	
-		starpu_spin_lock(&r->lock);
+		_starpu_spin_lock(&r->lock);
 	
 		/* wait until the transfer is terminated */
 		if (force)
@@ -381,8 +381,8 @@ static void _handle_pending_node_data_requests(uint32_t src_node, unsigned force
 				starpu_handle_data_request_completion(r);
 			}
 			else {
-				starpu_spin_unlock(&r->lock);
-				starpu_spin_unlock(&handle->header_lock);
+				_starpu_spin_unlock(&r->lock);
+				_starpu_spin_unlock(&handle->header_lock);
 
 				/* wake the requesting worker up */
 				pthread_mutex_lock(&data_requests_pending_list_mutex[src_node]);

src/datawizard/hierarchy.c

@@ -57,10 +57,10 @@ void _starpu_register_new_data(starpu_data_handle handle, uint32_t home_node, ui
 	/* initialize the new lock */
 	handle->req_list = starpu_data_requester_list_new();
 	handle->refcnt = 0;
-	starpu_spin_init(&handle->header_lock);
+	_starpu_spin_init(&handle->header_lock);
 
 	/* first take care to properly lock the data */
-	starpu_spin_lock(&handle->header_lock);
+	_starpu_spin_lock(&handle->header_lock);
 
 	/* we assume that all nodes may use that data */
 	handle->nnodes = STARPU_MAXNODES;
@@ -93,7 +93,7 @@ void _starpu_register_new_data(starpu_data_handle handle, uint32_t home_node, ui
 	}
 
 	/* now the data is available ! */
-	starpu_spin_unlock(&handle->header_lock);
+	_starpu_spin_unlock(&handle->header_lock);
 }
 
 /*
@@ -177,7 +177,7 @@ void starpu_partition_data(starpu_data_handle initial_handle, starpu_filter *f)
 	int i;
 
 	/* first take care to properly lock the data header */
-	starpu_spin_lock(&initial_handle->header_lock);
+	_starpu_spin_lock(&initial_handle->header_lock);
 
 	/* there should not be mutiple filters applied on the same data */
 	STARPU_ASSERT(initial_handle->nchildren == 0);
@@ -204,7 +204,7 @@ void starpu_partition_data(starpu_data_handle initial_handle, starpu_filter *f)
 		/* initialize the chunk lock */
 		children->req_list = starpu_data_requester_list_new();
 		children->refcnt = 0;
-		starpu_spin_init(&children->header_lock);
+		_starpu_spin_init(&children->header_lock);
 
 		unsigned node;
 		for (node = 0; node < STARPU_MAXNODES; node++)
@@ -219,7 +219,7 @@ void starpu_partition_data(starpu_data_handle initial_handle, starpu_filter *f)
 	}
 
 	/* now let the header */
-	starpu_spin_unlock(&initial_handle->header_lock);
+	_starpu_spin_unlock(&initial_handle->header_lock);
 }
 
 void starpu_unpartition_data(starpu_data_handle root_handle, uint32_t gathering_node)
@@ -227,7 +227,7 @@ void starpu_unpartition_data(starpu_data_handle root_handle, uint32_t gathering_
 	unsigned child;
 	unsigned node;
 
-	starpu_spin_lock(&root_handle->header_lock);
+	_starpu_spin_lock(&root_handle->header_lock);
 
 #warning starpu_unpartition_data is not supported with NO_DATA_RW_LOCK yet ...
 
@@ -304,13 +304,13 @@ void starpu_unpartition_data(starpu_data_handle root_handle, uint32_t gathering_
 	root_handle->nchildren = 0;
 
 	/* now the parent may be used again so we release the lock */
-	starpu_spin_unlock(&root_handle->header_lock);
+	_starpu_spin_unlock(&root_handle->header_lock);
 }
 
 /* TODO move ! */
 void starpu_advise_if_data_is_important(starpu_data_handle handle, unsigned is_important)
 {
-	starpu_spin_lock(&handle->header_lock);
+	_starpu_spin_lock(&handle->header_lock);
 
 	/* first take all the children lock (in order !) */
 	unsigned child;
@@ -324,7 +324,7 @@ void starpu_advise_if_data_is_important(starpu_data_handle handle, unsigned is_i
 	handle->is_not_important = !is_important;
 
 	/* now the parent may be used again so we release the lock */
-	starpu_spin_unlock(&handle->header_lock);
+	_starpu_spin_unlock(&handle->header_lock);
 
 }
 

src/datawizard/memalloc.c

@@ -49,7 +49,7 @@ static void lock_all_subtree(starpu_data_handle handle)
 	if (handle->nchildren == 0)
 	{
 		/* this is a leaf */
-		while (starpu_spin_trylock(&handle->header_lock))
+		while (_starpu_spin_trylock(&handle->header_lock))
 			_starpu_datawizard_progress(_starpu_get_local_memory_node(), 0);
 	}
 	else {
@@ -67,7 +67,7 @@ static void unlock_all_subtree(starpu_data_handle handle)
 	if (handle->nchildren == 0)
 	{
 		/* this is a leaf */	
-		starpu_spin_unlock(&handle->header_lock);
+		_starpu_spin_unlock(&handle->header_lock);
 	}
 	else {
 		/* lock all sub-subtrees children 
@@ -493,11 +493,11 @@ static size_t liberate_memory_on_node(starpu_mem_chunk_t mc, uint32_t node)
 
 	starpu_data_handle handle = mc->data;
 
-//	while (starpu_spin_trylock(&handle->header_lock))
+//	while (_starpu_spin_trylock(&handle->header_lock))
 //		_starpu_datawizard_progress(_starpu_get_local_memory_node());
 
 #warning can we block here ?
-//	starpu_spin_lock(&handle->header_lock);
+//	_starpu_spin_lock(&handle->header_lock);
 
 	if (mc->automatically_allocated && (handle->per_node[node].refcnt == 0))
 	{
@@ -518,7 +518,7 @@ static size_t liberate_memory_on_node(starpu_mem_chunk_t mc, uint32_t node)
 		STARPU_ASSERT(handle->per_node[node].refcnt == 0);
 	}
 
-//	starpu_spin_unlock(&handle->header_lock);
+//	_starpu_spin_unlock(&handle->header_lock);
 
 	return liberated;
 }

src/datawizard/user_interactions.c

@@ -178,9 +178,9 @@ static void _prefetch_data_on_node(void *arg)
 
 	if (!statenode->async)
 	{
-		starpu_spin_lock(&statenode->state->header_lock);
+		_starpu_spin_lock(&statenode->state->header_lock);
 		_starpu_notify_data_dependencies(statenode->state);
-		starpu_spin_unlock(&statenode->state->header_lock);
+		_starpu_spin_unlock(&statenode->state->header_lock);
 	}
 
 }
@@ -213,9 +213,9 @@ int _starpu_prefetch_data_on_node_with_mode(starpu_data_handle handle, unsigned
 		/* remove the "lock"/reference */
 		if (!async)
 		{
-			starpu_spin_lock(&handle->header_lock);
+			_starpu_spin_lock(&handle->header_lock);
 			_starpu_notify_data_dependencies(handle);
-			starpu_spin_unlock(&handle->header_lock);
+			_starpu_spin_unlock(&handle->header_lock);
 		}
 	}
 	else {

src/datawizard/write_back.c

@@ -25,7 +25,7 @@ void _starpu_write_through_data(starpu_data_handle handle, uint32_t requesting_n
 		return;
 	}
 
-	while (starpu_spin_trylock(&handle->header_lock))
+	while (_starpu_spin_trylock(&handle->header_lock))
 		_starpu_datawizard_progress(requesting_node, 1);
 
 	/* first commit all changes onto the nodes specified by the mask */
@@ -53,13 +53,13 @@ void _starpu_write_through_data(starpu_data_handle handle, uint32_t requesting_n
 				else {
 					/* if there is already a similar request, it is
 					 * useless to post another one */
-					starpu_spin_unlock(&r->lock);
+					_starpu_spin_unlock(&r->lock);
 				}
 			}
 		}
 	}
 
-	starpu_spin_unlock(&handle->header_lock);
+	_starpu_spin_unlock(&handle->header_lock);
 }
 
 void starpu_data_set_wb_mask(starpu_data_handle handle, uint32_t wb_mask)