Merge branch 'master' of gitlab.inria.fr:starpu/starpu

include/starpu_data_filters.h

@@ -240,6 +240,12 @@ void starpu_data_partition_submit(starpu_data_handle_t initial_handle, unsigned
 void starpu_data_partition_readonly_submit(starpu_data_handle_t initial_handle, unsigned nparts, starpu_data_handle_t *children);
 
 /**
+ * Similar to starpu_data_partition_readonly_submit(), but allow to
+ * specify the the coherency to be used for the main data \p initial_handle
+ */
+void starpu_data_partition_readonly_submit_sequential_consistency(starpu_data_handle_t initial_handle, unsigned nparts, starpu_data_handle_t *children, int sequential_consistency);
+
+/**
    Assume that a partitioning of \p initial_handle has already been submited
    in readonly mode through starpu_data_partition_readonly_submit(), and will upgrade
    that partitioning into read-write mode for the \p children, by invalidating \p

include/starpu_task.h

@@ -1763,6 +1763,11 @@ void starpu_task_ft_success(struct starpu_task *meta_task);
 */
 void starpu_task_watchdog_set_hook(void (*hook)(void *), void *hook_arg);
 
+/**
+ * Return the given status as a string
+ */
+char *starpu_task_status_get_as_string(enum starpu_task_status status);
+
 /** @} */
 
 #ifdef __cplusplus

src/common/fxt.h

@@ -242,6 +242,7 @@
 #define _STARPU_FUT_PAPI_TASK_EVENT_VALUE   0x5186
 #define _STARPU_FUT_TASK_EXCLUDE_FROM_DAG   0x5187
 
+#define _STARPU_FUT_TASK_END_DEP	0x5188
 
 /* Predefined FUT key masks */
 #define _STARPU_FUT_KEYMASK_META           FUT_KEYMASK0
@@ -856,6 +857,9 @@ do {									\
 #define _STARPU_TRACE_TASK_DEPS(job_prev, job_succ)	\
 	_STARPU_FUT_FULL_PROBE4STR(_STARPU_FUT_KEYMASK_TASK, _STARPU_FUT_TASK_DEPS, (job_prev)->job_id, (job_succ)->job_id, (job_succ)->task->type, 1, "task")
 
+#define _STARPU_TRACE_TASK_END_DEP(job_prev, job_succ) \
+	FUT_DO_PROBE2(_STARPU_FUT_TASK_END_DEP, (job_prev)->job_id, (job_succ)->job_id)
+
 #define _STARPU_TRACE_GHOST_TASK_DEPS(ghost_prev_id, job_succ)		\
 	_STARPU_FUT_FULL_PROBE4STR(_STARPU_FUT_KEYMASK_TASK_VERBOSE, _STARPU_FUT_TASK_DEPS, (ghost_prev_id), (job_succ)->job_id, (job_succ)->task->type, 1, "ghost")
 
@@ -1364,6 +1368,7 @@ do {										\
 #define _STARPU_TRACE_TAG(tag, job)		do {(void)(tag); (void)(job);} while(0)
 #define _STARPU_TRACE_TAG_DEPS(a, b)		do {(void)(a); (void)(b);} while(0)
 #define _STARPU_TRACE_TASK_DEPS(a, b)		do {(void)(a); (void)(b);} while(0)
+#define _STARPU_TRACE_TASK_END_DEP(a, b)	do {(void)(a); (void)(b);} while(0)
 #define _STARPU_TRACE_GHOST_TASK_DEPS(a, b)	do {(void)(a); (void)(b);} while(0)
 #define _STARPU_TRACE_TASK_EXCLUDE_FROM_DAG(a)	do {(void)(a);} while(0)
 #define _STARPU_TRACE_TASK_NAME(a)		do {(void)(a);} while(0)

src/core/jobs.c

@@ -303,6 +303,16 @@ void _starpu_handle_job_submission(struct _starpu_job *j)
 void starpu_task_end_dep_release(struct starpu_task *t)
 {
 	struct _starpu_job *j = _starpu_get_job_associated_to_task(t);
+
+#ifdef STARPU_USE_FXT
+	struct starpu_task *current = starpu_task_get_current();
+	if (current)
+	{
+		struct _starpu_job *jcurrent = _starpu_get_job_associated_to_task(current);
+		_STARPU_TRACE_TASK_END_DEP(jcurrent, j);
+	}
+#endif
+
 	_starpu_handle_job_termination(j);
 }
 

src/core/task.c

@@ -1697,3 +1697,20 @@ void starpu_task_ft_success(struct starpu_task *meta_task)
 {
 	starpu_task_end_dep_release(meta_task);
 }
+
+char *starpu_task_status_get_as_string(enum starpu_task_status status)
+{
+	switch(status)
+	{
+	case(STARPU_TASK_INIT) : return "STARPU_TASK_INIT";
+	case(STARPU_TASK_BLOCKED): return "STARPU_TASK_BLOCKED";
+	case(STARPU_TASK_READY): return "STARPU_TASK_READY";
+	case(STARPU_TASK_RUNNING): return "STARPU_TASK_RUNNING";
+	case(STARPU_TASK_FINISHED): return "STARPU_TASK_FINISHED";
+	case(STARPU_TASK_BLOCKED_ON_TAG): return "STARPU_TASK_BLOCKED_ON_TAG";
+	case(STARPU_TASK_BLOCKED_ON_TASK): return "STARPU_TASK_BLOCKED_ON_TASK";
+	case(STARPU_TASK_BLOCKED_ON_DATA): return "STARPU_TASK_BLOCKED_ON_DATA";
+	case(STARPU_TASK_STOPPED): return "STARPU_TASK_STOPPED";
+	default: return "STARPU_TASK_unknown_status";
+	}
+}

src/datawizard/filters.c

@@ -710,6 +710,11 @@ void starpu_data_partition_submit(starpu_data_handle_t initial_handle, unsigned
 
 void starpu_data_partition_readonly_submit(starpu_data_handle_t initial_handle, unsigned nparts, starpu_data_handle_t *children)
 {
+	starpu_data_partition_readonly_submit_sequential_consistency(initial_handle, nparts, children, initial_handle->sequential_consistency);
+}
+
+void starpu_data_partition_readonly_submit_sequential_consistency(starpu_data_handle_t initial_handle, unsigned nparts, starpu_data_handle_t *children, int sequential_consistency)
+{
 	unsigned i;
 	STARPU_ASSERT_MSG(initial_handle->sequential_consistency, "partition planning is currently only supported for data with sequential consistency");
 	_starpu_spin_lock(&initial_handle->header_lock);
@@ -737,14 +742,22 @@ void starpu_data_partition_readonly_submit(starpu_data_handle_t initial_handle,
 
 	STARPU_ASSERT_MSG(initial_handle->initialized, "It is odd to read-only-partition a data which does not have a value yet");
 	struct starpu_data_descr descr[nparts];
+	char handles_sequential_consistency[nparts+1];
+	handles_sequential_consistency[0] = sequential_consistency;
+
 	for (i = 0; i < nparts; i++)
 	{
 		STARPU_ASSERT_MSG(children[i]->father_handle == initial_handle, "child(%d) %p is partitioned from %p and not from the given parameter %p", i, children[i], children[i]->father_handle, initial_handle);
 		descr[i].handle = children[i];
 		descr[i].mode = STARPU_W;
+		handles_sequential_consistency[i+1] = (char) children[i]->sequential_consistency;
 	}
 	/* TODO: assert nparts too */
-	starpu_task_insert(initial_handle->switch_cl, STARPU_R, initial_handle, STARPU_DATA_MODE_ARRAY, descr, nparts, 0);
+	int ret = starpu_task_insert(initial_handle->switch_cl, STARPU_R, initial_handle,
+				     STARPU_DATA_MODE_ARRAY, descr, nparts,
+				     STARPU_HANDLES_SEQUENTIAL_CONSISTENCY, handles_sequential_consistency,
+				     0);
+	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
 }
 
 void starpu_data_partition_readwrite_upgrade_submit(starpu_data_handle_t initial_handle, unsigned nparts, starpu_data_handle_t *children)
@@ -771,7 +784,8 @@ void starpu_data_partition_readwrite_upgrade_submit(starpu_data_handle_t initial
 		descr[i].mode = STARPU_W;
 	}
 	/* TODO: assert nparts too */
-	starpu_task_insert(initial_handle->switch_cl, STARPU_RW, initial_handle, STARPU_DATA_MODE_ARRAY, descr, nparts, 0);
+	int ret = starpu_task_insert(initial_handle->switch_cl, STARPU_RW, initial_handle, STARPU_DATA_MODE_ARRAY, descr, nparts, 0);
+	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
 	starpu_data_invalidate_submit(initial_handle);
 }
 
@@ -898,7 +912,8 @@ void starpu_data_unpartition_readonly_submit(starpu_data_handle_t initial_handle
 		n++;
 	}
 	/* TODO: assert nparts too */
-	starpu_task_insert(initial_handle->switch_cl, STARPU_W, initial_handle, STARPU_DATA_MODE_ARRAY, descr, n, 0);
+	int ret = starpu_task_insert(initial_handle->switch_cl, STARPU_W, initial_handle, STARPU_DATA_MODE_ARRAY, descr, n, 0);
+	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert")
 }
 
 /* Unpartition everything below ancestor */

src/debug/traces/starpu_fxt.c

@@ -114,6 +114,8 @@ struct task_info
 	char *parameters;
 	unsigned int ndeps;
 	unsigned long *dependencies;
+	unsigned int nend_deps;
+	unsigned long *end_dependencies;
 	char **dep_labels;
 	unsigned long ndata;
 	struct data_parameter_info *data;
@@ -155,6 +157,8 @@ static struct task_info *get_task(unsigned long job_id, int mpi_rank)
 		task->parameters = NULL;
 		task->ndeps = 0;
 		task->dependencies = NULL;
+		task->nend_deps = 0;
+		task->end_dependencies = NULL;
 		task->dep_labels = NULL;
 		task->ndata = 0;
 		task->data = NULL;
@@ -265,6 +269,14 @@ static void task_dump(struct task_info *task, struct starpu_fxt_options *options
 		fprintf(tasks_file, "\n");
 	}
 	fprintf(tasks_file, "MPIRank: %d\n", task->mpi_rank);
+	if (task->nend_deps)
+	{
+		fprintf(tasks_file, "EndDependencies: ");
+		unsigned int j=0;
+		for(j=0 ; j<task->nend_deps-1 ; j++)
+			fprintf(tasks_file, "%lu, ", task->end_dependencies[j]);
+		fprintf(tasks_file, "%lu ", task->end_dependencies[task->nend_deps-1]);
+	}
 	fprintf(tasks_file, "\n");
 
 out:
@@ -2736,6 +2748,36 @@ static void handle_task_deps(struct fxt_ev_64 *ev, struct starpu_fxt_options *op
 	}
 }
 
+static void handle_task_end_dep(struct fxt_ev_64 *ev, struct starpu_fxt_options *options)
+{
+	unsigned long dep_prev = ev->param[0];
+	unsigned long dep_succ = ev->param[1];
+
+	struct task_info *task = get_task(dep_succ, options->file_rank);
+	unsigned alloc = 0;
+
+	if (task->nend_deps == 0)
+		/* Start with 8=2^3, should be plenty in most cases */
+		alloc = 8;
+	else if (task->nend_deps >= 8)
+	{
+		/* Allocate dependencies array by powers of two */
+		if (! ((task->nend_deps - 1) & task->nend_deps)) /* Is task->ndeps a power of two? */
+		{
+			/* We have filled the previous power of two, get another one */
+			alloc = task->nend_deps * 2;
+		}
+	}
+	if (alloc)
+	{
+		_STARPU_REALLOC(task->end_dependencies, sizeof(*task->end_dependencies) * alloc);
+	}
+	task->end_dependencies[task->nend_deps++] = dep_prev;
+
+	if (!task->exclude_from_dag && show_task(task, options))
+		_starpu_fxt_dag_add_task_end_dep(options->file_prefix, dep_succ, dep_prev);
+}
+
 static void handle_task_submit(struct fxt_ev_64 *ev, struct starpu_fxt_options *options)
 {
 	unsigned long job_id = ev->param[0];
@@ -3514,6 +3556,10 @@ void _starpu_fxt_parse_new_file(char *filename_in, struct starpu_fxt_options *op
 				handle_task_deps(&ev, options);
 				break;
 
+			case _STARPU_FUT_TASK_END_DEP:
+				handle_task_end_dep(&ev, options);
+				break;
+
 			case _STARPU_FUT_TASK_SUBMIT:
 				handle_task_submit(&ev, options);
 				break;

src/debug/traces/starpu_fxt.h

@@ -51,6 +51,7 @@ void _starpu_fxt_dag_add_tag(const char *prefix, uint64_t tag, unsigned long job
 void _starpu_fxt_dag_add_tag_deps(const char *prefix, uint64_t child, uint64_t father, const char *label);
 void _starpu_fxt_dag_set_tag_done(const char *prefix, uint64_t tag, const char *color);
 void _starpu_fxt_dag_add_task_deps(const char *prefix, unsigned long dep_prev, unsigned long dep_succ, const char *label);
+void _starpu_fxt_dag_add_task_end_dep(const char *prefix, unsigned long prev, unsigned long succ);
 void _starpu_fxt_dag_set_task_name(const char *prefix, unsigned long job_id, const char *label, const char *color);
 void _starpu_fxt_dag_set_task_line(const char *prefix, unsigned long job_id, const char *file, int line);
 void _starpu_fxt_dag_add_send(int src, unsigned long dep_prev, unsigned long tag, unsigned long id);

src/debug/traces/starpu_fxt_dag.c

@@ -104,6 +104,12 @@ void _starpu_fxt_dag_set_tag_done(const char *prefix, uint64_t tag, const char *
 			prefix, (unsigned long long)tag, color);
 }
 
+void _starpu_fxt_dag_add_task_end_dep(const char *prefix, unsigned long prev, unsigned long succ)
+{
+	if (out_file)
+		fprintf(out_file, "\t \"task_%s%lu\" [ end_dep=\"%lu\"]\n", prefix, prev, succ);
+}
+
 void _starpu_fxt_dag_set_task_name(const char *prefix, unsigned long job_id, const char *label, const char *color)
 {
 	if (out_file)

src/util/starpu_task_insert.c

@@ -24,11 +24,31 @@
 
 void starpu_codelet_pack_args(void **arg_buffer, size_t *arg_buffer_size, ...)
 {
+	struct starpu_codelet_pack_arg_data state;
 	va_list varg_list;
+	int arg_type;
+
+	starpu_codelet_pack_arg_init(&state);
 
 	va_start(varg_list, arg_buffer_size);
-	_starpu_codelet_pack_args(arg_buffer, arg_buffer_size, varg_list);
+	while((arg_type = va_arg(varg_list, int)) != 0)
+	{
+		if (arg_type==STARPU_VALUE)
+		{
+			/* We have a constant value: this should be followed by a pointer to the cst value and the size of the constant */
+			void *ptr = va_arg(varg_list, void *);
+			size_t ptr_size = va_arg(varg_list, size_t);
+
+			starpu_codelet_pack_arg(&state, ptr, ptr_size);
+		}
+		else
+		{
+			STARPU_ABORT_MSG("Unrecognized argument %d, did you perhaps forget to end arguments with 0?\n", arg_type);
+		}
+	}
 	va_end(varg_list);
+
+	starpu_codelet_pack_arg_fini(&state, arg_buffer, arg_buffer_size);
 }
 
 void _starpu_codelet_unpack_args_and_copyleft(char *cl_arg, void *_buffer, size_t buffer_size, va_list varg_list)

src/util/starpu_task_insert_utils.c

@@ -126,218 +126,6 @@ void starpu_codelet_unpack_discard_arg(struct starpu_codelet_pack_arg_data *stat
 	state->nargs++;
 }
 
-int _starpu_codelet_pack_args(void **arg_buffer, size_t *arg_buffer_size, va_list varg_list)
-{
-	int arg_type;
-
-	struct starpu_codelet_pack_arg_data state;
-	starpu_codelet_pack_arg_init(&state);
-
-	while((arg_type = va_arg(varg_list, int)) != 0)
-	{
-		if (arg_type & STARPU_R || arg_type & STARPU_W || arg_type & STARPU_SCRATCH || arg_type & STARPU_REDUX)
-		{
-			(void)va_arg(varg_list, starpu_data_handle_t);
-		}
-		else if (arg_type==STARPU_DATA_ARRAY)
-		{
-			(void)va_arg(varg_list, starpu_data_handle_t*);
-			(void)va_arg(varg_list, int);
-		}
-		else if (arg_type==STARPU_DATA_MODE_ARRAY)
-		{
-			(void)va_arg(varg_list, struct starpu_data_descr*);
-			(void)va_arg(varg_list, int);
-		}
-		else if (arg_type==STARPU_VALUE)
-		{
-			/* We have a constant value: this should be followed by a pointer to the cst value and the size of the constant */
-			void *ptr = va_arg(varg_list, void *);
-			size_t ptr_size = va_arg(varg_list, size_t);
-
-			starpu_codelet_pack_arg(&state, ptr, ptr_size);
-		}
-		else if (arg_type==STARPU_CL_ARGS)
-		{
-			(void)va_arg(varg_list, void *);
-			(void)va_arg(varg_list, size_t);
-		}
-		else if (arg_type==STARPU_CL_ARGS_NFREE)
-		{
-			(void)va_arg(varg_list, void *);
-			(void)va_arg(varg_list, size_t);
-		}
-		else if (arg_type==STARPU_TASK_DEPS_ARRAY)
-		{
-			(void)va_arg(varg_list, unsigned);
-			(void)va_arg(varg_list, struct starpu_task **);
-		}
-		else if (arg_type==STARPU_TASK_END_DEPS_ARRAY)
-		{
-			(void)va_arg(varg_list, unsigned);
-			(void)va_arg(varg_list, struct starpu_task **);
-		}
-		else if (arg_type==STARPU_CALLBACK)
-		{
-			(void)va_arg(varg_list, _starpu_callback_func_t);
-		}
-		else if (arg_type==STARPU_CALLBACK_WITH_ARG)
-		{
-			va_arg(varg_list, _starpu_callback_func_t);
-			va_arg(varg_list, void *);
-		}
-		else if (arg_type==STARPU_CALLBACK_WITH_ARG_NFREE)
-		{
-			va_arg(varg_list, _starpu_callback_func_t);
-			va_arg(varg_list, void *);
-		}
-		else if (arg_type==STARPU_CALLBACK_ARG)
-		{
-			(void)va_arg(varg_list, void *);
-		}
-		else if (arg_type==STARPU_CALLBACK_ARG_NFREE)
-		{
-			(void)va_arg(varg_list, void *);
-		}
-		else if (arg_type==STARPU_EPILOGUE_CALLBACK)
-		{
-			(void)va_arg(varg_list, _starpu_callback_func_t);
-		}
-		else if (arg_type==STARPU_EPILOGUE_CALLBACK_ARG)
-		{
-			(void)va_arg(varg_list, void *);
-		}
-		else if (arg_type==STARPU_PROLOGUE_CALLBACK)
-		{
-			va_arg(varg_list, _starpu_callback_func_t);
-		}
-		else if (arg_type==STARPU_PROLOGUE_CALLBACK_ARG)
-		{
-			(void)va_arg(varg_list, void *);
-		}
-		else if (arg_type==STARPU_PROLOGUE_CALLBACK_ARG_NFREE)
-		{
-			(void)va_arg(varg_list, void *);
-		}
-		else if (arg_type==STARPU_PROLOGUE_CALLBACK_POP)
-		{
-			va_arg(varg_list, _starpu_callback_func_t);
-		}
-		else if (arg_type==STARPU_PROLOGUE_CALLBACK_POP_ARG)
-		{
-			(void)va_arg(varg_list, void *);
-		}
-		else if (arg_type==STARPU_PROLOGUE_CALLBACK_POP_ARG_NFREE)
-		{
-			(void)va_arg(varg_list, void *);
-		}
-		else if (arg_type==STARPU_PRIORITY)
-		{
-			(void)va_arg(varg_list, int);
-		}
-		else if (arg_type==STARPU_EXECUTE_ON_NODE)
-		{
-			(void)va_arg(varg_list, int);
-		}
-		else if (arg_type==STARPU_EXECUTE_ON_DATA)
-		{
-			(void)va_arg(varg_list, starpu_data_handle_t);
-		}
-		else if (arg_type==STARPU_EXECUTE_WHERE)
-		{
-			(void)va_arg(varg_list, unsigned long long);
-		}
-		else if (arg_type==STARPU_EXECUTE_ON_WORKER)
-		{
-			(void)va_arg(varg_list, int);
-		}
-		else if (arg_type==STARPU_WORKER_ORDER)
-		{
-			va_arg(varg_list, unsigned);
-		}
-		else if (arg_type==STARPU_SCHED_CTX)
-		{
-			(void)va_arg(varg_list, unsigned);
-		}
-		else if (arg_type==STARPU_HYPERVISOR_TAG)
-		{
-			(void)va_arg(varg_list, int);
-		}
-		else if (arg_type==STARPU_POSSIBLY_PARALLEL)
-		{
-			(void)va_arg(varg_list, unsigned);
-		}
-		else if (arg_type==STARPU_FLOPS)
-		{
-			(void)va_arg(varg_list, double);
-		}
-		else if (arg_type==STARPU_TAG || arg_type==STARPU_TAG_ONLY)
-		{
-			(void)va_arg(varg_list, starpu_tag_t);
-		}
-		else if (arg_type==STARPU_NAME)
-		{
-			(void)va_arg(varg_list, const char *);
-		}
-		else if (arg_type==STARPU_NODE_SELECTION_POLICY)
-		{
-			(void)va_arg(varg_list, int);
-		}
-		else if (arg_type==STARPU_TASK_COLOR)
-                {
-                        (void)va_arg(varg_list, int);
-                }
-		else if (arg_type==STARPU_TASK_SYNCHRONOUS)
-                {
-                        (void)va_arg(varg_list, int);
-                }
-		else if (arg_type==STARPU_HANDLES_SEQUENTIAL_CONSISTENCY)
-                {
-                        (void)va_arg(varg_list, unsigned char *);
-                }
-		else if (arg_type==STARPU_TASK_END_DEP)
-		{
-			(void)va_arg(varg_list, int);
-		}
-		else if (arg_type==STARPU_TASK_WORKERIDS)
-		{
-			(void)va_arg(varg_list, unsigned);
-			(void)va_arg(varg_list, uint32_t*);
-		}
-		else if (arg_type==STARPU_SEQUENTIAL_CONSISTENCY)
-		{
-			(void)va_arg(varg_list, unsigned);
-		}
-		else if (arg_type==STARPU_TASK_PROFILING_INFO)
-		{
-			(void)va_arg(varg_list, struct starpu_profiling_task_info *);
-		}
-		else if (arg_type==STARPU_TASK_NO_SUBMITORDER)
-		{
-			(void)va_arg(varg_list, unsigned);
-		}
-		else if (arg_type==STARPU_TASK_SCHED_DATA)
-		{
-			(void)va_arg(varg_list, void *);
-		}
-		else if (arg_type==STARPU_TASK_FILE)
-		{
-			(void)va_arg(varg_list, const char *);
-		}
-		else if (arg_type==STARPU_TASK_LINE)
-		{
-			(void)va_arg(varg_list, int);
-		}
-		else
-		{
-			STARPU_ABORT_MSG("Unrecognized argument %d, did you perhaps forget to end arguments with 0?\n", arg_type);
-		}
-	}
-
-	starpu_codelet_pack_arg_fini(&state, arg_buffer, arg_buffer_size);
-	return 0;
-}
-
 void starpu_task_insert_data_make_room(struct starpu_codelet *cl, struct starpu_task *task, int *allocated_buffers, int current_buffer, int room)
 {
 	if (current_buffer + room > STARPU_NMAXBUFS)

tests/Makefile.am

@@ -418,6 +418,7 @@ endif
 endif
 
 examplebin_PROGRAMS = \
+	main/deadlock				\
 	microbenchs/async_tasks_overhead	\
 	microbenchs/sync_tasks_overhead		\
 	microbenchs/tasks_overhead		\

tests/main/deadlock.c

@@ -0,0 +1,71 @@
+/* StarPU --- Runtime system for heterogeneous multicore architectures.
+ *
+ * Copyright (C) 2010-2021  Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
+ *
+ * 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
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * StarPU is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * See the GNU Lesser General Public License in COPYING.LGPL for more details.
+ */
+
+#include <starpu.h>
+#include "../helper.h"
+
+/*
+ * Create a cycle of tasks with NULL codelet, using manual dependencies.
+ * This is meant to try debugging tools with such a deadlock case.
+ */
+
+#define N	4
+
+int main(int argc, char **argv)
+{
+	int i, ret;
+
+	ret = starpu_initialize(NULL, &argc, &argv);
+	if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
+	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
+
+	struct starpu_task **tasks = (struct starpu_task **) malloc(N*sizeof(struct starpu_task *));
+
+	for (i = 0; i < N; i++)
+	{
+		tasks[i] = starpu_task_create();
+		tasks[i]->cl = NULL;
+	}
+
+	for (i = 0; i < N; i++)
+	{
+		if (i > 0)
+			starpu_task_declare_deps_array(tasks[i], 1, &tasks[i-1]);
+		else
+			starpu_task_declare_deps_array(tasks[i], 1, &tasks[N-1]);
+	}
+
+	for (i = 0; i < N; i++)
+	{
+		ret = starpu_task_submit(tasks[i]);
+		if (ret == -ENODEV) goto enodev;
+		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
+	}
+
+	starpu_task_wait_for_all();
+
+	starpu_shutdown();
+	free(tasks);
+
+	return EXIT_SUCCESS;
+
+enodev:
+	fprintf(stderr, "WARNING: No one can execute this task\n");
+	/* yes, we do not perform the computation but we did detect that no one
+ 	 * could perform the kernel, so this is not an error from StarPU */
+	starpu_shutdown();
+	return STARPU_TEST_SKIPPED;
+}