Check that the handle spinlock is held when manipulating refcnts

src/common/starpu_spinlock.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010  Université de Bordeaux 1
+ * Copyright (C) 2010, 2012  Université de Bordeaux 1
  * Copyright (C) 2010, 2011  Centre National de la Recherche Scientifique
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -85,6 +85,24 @@ int _starpu_spin_lock(struct _starpu_spinlock *lock)
 #endif
 }
 
+int _starpu_spin_checklocked(struct _starpu_spinlock *lock)
+{
+#ifdef STARPU_SPINLOCK_CHECK
+	int ret = pthread_mutex_trylock(&lock->errcheck_lock);
+	STARPU_ASSERT(ret == EDEADLK);
+	return ret != EDEADLK;
+#else
+#ifdef HAVE_PTHREAD_SPIN_LOCK
+	int ret = pthread_spin_trylock(&lock->lock);
+	STARPU_ASSERT(ret != 0);
+	return ret == 0;
+#else
+	STARPU_ASSERT(lock->taken);
+	return !lock->taken;
+#endif
+#endif
+}
+
 int _starpu_spin_trylock(struct _starpu_spinlock *lock)
 {
 #ifdef STARPU_SPINLOCK_CHECK

src/common/starpu_spinlock.h

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010-2011  Université de Bordeaux 1
+ * Copyright (C) 2010-2012  Université de Bordeaux 1
  * Copyright (C) 2010, 2011  Centre National de la Recherche Scientifique
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -43,6 +43,7 @@ int _starpu_spin_destroy(struct _starpu_spinlock *lock);
 
 int _starpu_spin_lock(struct _starpu_spinlock *lock);
 int _starpu_spin_trylock(struct _starpu_spinlock *lock);
+int _starpu_spin_checklocked(struct _starpu_spinlock *lock);
 int _starpu_spin_unlock(struct _starpu_spinlock *lock);
 
 #endif // __STARPU_SPINLOCK_H__

src/core/dependencies/data_concurrency.c

@@ -263,6 +263,7 @@ static unsigned unlock_one_requester(struct _starpu_data_requester *r)
 /* The header lock must already be taken by the caller */
 void _starpu_notify_data_dependencies(starpu_data_handle_t handle)
 {
+	_starpu_spin_checklocked(&handle->header_lock);
 	/* A data access has finished so we remove a reference. */
 	STARPU_ASSERT(handle->refcnt > 0);
 	handle->refcnt--;

src/core/perfmodel/perfmodel.c

@@ -287,6 +287,7 @@ double starpu_task_expected_conversion_time(struct starpu_task *task,
 
 		conversion_task = _starpu_create_conversion_task(handle, node);
 		sum += starpu_task_expected_length(conversion_task, arch, nimpl);
+		_starpu_spin_checklocked(&handle->header_lock);
 		handle->refcnt--;
 		handle->busy_count--;
 		starpu_task_deinit(conversion_task);

src/core/sched_policy.c

@@ -332,6 +332,7 @@ struct starpu_task *_starpu_create_conversion_task(starpu_data_handle_t handle,
 	format_interface = (struct starpu_multiformat_interface *) starpu_data_get_interface_on_node(handle, 0);
 	node_kind = starpu_node_get_kind(node);
 
+	_starpu_spin_checklocked(&handle->header_lock);
 	handle->refcnt++;
 	handle->busy_count++;
 

src/datawizard/coherency.c

@@ -282,6 +282,8 @@ static struct _starpu_data_request *_starpu_search_existing_data_request(struct
 
 	if (r)
 	{
+		_starpu_spin_checklocked(&r->handle->header_lock);
+
 		_starpu_spin_lock(&r->lock);
 
                 /* perhaps we need to "upgrade" the request */

src/datawizard/data_request.c

@@ -90,6 +90,8 @@ struct _starpu_data_request *_starpu_create_data_request(starpu_data_handle_t ha
 {
 	struct _starpu_data_request *r = _starpu_data_request_new();
 
+	_starpu_spin_checklocked(&handle->header_lock);
+
 	_starpu_spin_init(&r->lock);
 
 	r->handle = handle;
@@ -235,6 +237,8 @@ static void starpu_handle_data_request_completion(struct _starpu_data_request *r
 #ifdef STARPU_MEMORY_STATUS
 	enum _starpu_cache_state old_src_replicate_state = src_replicate->state;
 #endif
+
+	_starpu_spin_checklocked(&handle->header_lock);
 	_starpu_update_data_state(handle, r->dst_replicate, mode);
 
 #ifdef STARPU_MEMORY_STATUS

src/datawizard/memalloc.c

@@ -158,6 +158,7 @@ static void transfer_subtree_to_node(starpu_data_handle_t handle, unsigned src_n
 #endif
 			/* TODO use request !! */
 			/* Take temporary references on the replicates */
+			_starpu_spin_checklocked(&handle->header_lock);
 			src_replicate->refcnt++;
 			dst_replicate->refcnt++;
 			handle->busy_count+=2;
@@ -752,6 +753,8 @@ static ssize_t _starpu_allocate_interface(starpu_data_handle_t handle, struct _s
 	unsigned attempts = 0;
 	ssize_t allocated_memory;
 
+	_starpu_spin_checklocked(&handle->header_lock);
+
 	_starpu_data_allocation_inc_stats(dst_node);
 
 #ifdef STARPU_USE_ALLOCATION_CACHE

src/datawizard/reduction.c

@@ -113,6 +113,8 @@ void _starpu_data_end_reduction_mode(starpu_data_handle_t handle)
 	unsigned replicate_count = 0;
 	starpu_data_handle_t replicate_array[1 + STARPU_NMAXWORKERS];
 
+	_starpu_spin_checklocked(&handle->header_lock);
+
 	for (node = 0; node < STARPU_MAXNODES; node++)
 	{
 		if (handle->per_node[node].state != STARPU_INVALID)
@@ -328,6 +330,9 @@ void _starpu_data_end_reduction_mode_terminate(starpu_data_handle_t handle)
 
 //	fprintf(stderr, "_starpu_data_end_reduction_mode_terminate\n");
 	unsigned worker;
+
+	_starpu_spin_checklocked(&handle->header_lock);
+
 	for (worker = 0; worker < nworkers; worker++)
 	{
 		struct _starpu_data_replicate *replicate;

src/datawizard/user_interactions.c

@@ -216,6 +216,7 @@ int starpu_data_acquire(starpu_data_handle_t handle, enum starpu_access_mode mod
 	{
 		struct starpu_task *task = _starpu_create_conversion_task(handle, 0);
 		int ret;
+		_starpu_spin_checklocked(&handle->header_lock);
 		handle->refcnt--;
 		handle->busy_count--;
 		handle->mf_node = 0;