In case starpu_tag_declare_deps is passed constant arguments, the caller

must make sure that the constants have the same size as starpu_tag_t.
Otherwise, nothing prevents the C compiler to consider the tag 0x20000003
instead of 0x2 and 0x3 when calling:
    "starpu_tag_declare_deps(0x1, 2, 0x2, 0x3)"
Using starpu_tag_declare_deps_array is a way to avoid this problem.

examples/cholesky/dw_cholesky.h

@@ -30,12 +30,12 @@
 
 #define NMAXBLOCKS	32
 
-#define TAG11(k)	( (1ULL<<60) | (unsigned long long)(k))
-#define TAG21(k,j)	(((3ULL<<60) | (((unsigned long long)(k))<<32)	\
-					| (unsigned long long)(j)))
-#define TAG22(k,i,j)	(((4ULL<<60) | ((unsigned long long)(k)<<32) 	\
+#define TAG11(k)	((starpu_tag_t)( (1ULL<<60) | (unsigned long long)(k)))
+#define TAG21(k,j)	((starpu_tag_t)(((3ULL<<60) | (((unsigned long long)(k))<<32)	\
+					| (unsigned long long)(j))))
+#define TAG22(k,i,j)	((starpu_tag_t)(((4ULL<<60) | ((unsigned long long)(k)<<32) 	\
 					| ((unsigned long long)(i)<<16)	\
-					| (unsigned long long)(j)))
+					| (unsigned long long)(j))))
 
 #define BLOCKSIZE	(size/nblocks)
 

examples/heat/dw_factolu_tag.c

@@ -16,14 +16,14 @@
 
 #include "dw_factolu.h"
 
-#define TAG11(k)	( (1ULL<<60) | (unsigned long long)(k))
-#define TAG12(k,i)	(((2ULL<<60) | (((unsigned long long)(k))<<32)	\
-					| (unsigned long long)(i)))
-#define TAG21(k,j)	(((3ULL<<60) | (((unsigned long long)(k))<<32)	\
-					| (unsigned long long)(j)))
-#define TAG22(k,i,j)	(((4ULL<<60) | ((unsigned long long)(k)<<32) 	\
+#define TAG11(k)	((starpu_tag_t)( (1ULL<<60) | (unsigned long long)(k)))
+#define TAG12(k,i)	((starpu_tag_t)(((2ULL<<60) | (((unsigned long long)(k))<<32)	\
+					| (unsigned long long)(i))))
+#define TAG21(k,j)	((starpu_tag_t)(((3ULL<<60) | (((unsigned long long)(k))<<32)	\
+					| (unsigned long long)(j))))
+#define TAG22(k,i,j)	((starpu_tag_t)(((4ULL<<60) | ((unsigned long long)(k)<<32) 	\
 					| ((unsigned long long)(i)<<16)	\
-					| (unsigned long long)(j)))
+					| (unsigned long long)(j))))
 
 /*
  *	Construct the DAG

examples/heat/dw_sparse_cg.c

@@ -190,7 +190,7 @@ void init_cg(struct cg_problem *problem)
 		task2->buffers[1].state = problem->ds_vecr;
 		task2->buffers[1].mode = R;
 	
-	starpu_tag_declare_deps(2UL, 1, 1UL);
+	starpu_tag_declare_deps((starpu_tag_t)2UL, 1, (starpu_tag_t)1UL);
 
 	/* delta_new = trans(r) r */
 	struct starpu_task *task3 = create_task(3UL);
@@ -208,7 +208,7 @@ void init_cg(struct cg_problem *problem)
 	task3->callback_arg = problem;
 	
 	/* XXX 3 should only depend on 1 ... */
-	starpu_tag_declare_deps(3UL, 1, 2UL);
+	starpu_tag_declare_deps((starpu_tag_t)3UL, 1, (starpu_tag_t)2UL);
 
 	/* launch the computation now */
 	starpu_submit_task(task1);
@@ -253,7 +253,7 @@ void launch_new_cg_iteration(struct cg_problem *problem)
 		task5->buffers[1].state = problem->ds_vecq;
 		task5->buffers[1].mode = R;
 
-	starpu_tag_declare_deps(maskiter | 5UL, 1, maskiter | 4UL);
+	starpu_tag_declare_deps((starpu_tag_t)(maskiter | 5UL), 1, (starpu_tag_t)(maskiter | 4UL));
 
 	/* x = x + alpha d */
 	struct starpu_task *task6 = create_task(maskiter | 6UL);
@@ -269,7 +269,7 @@ void launch_new_cg_iteration(struct cg_problem *problem)
 		task6->buffers[1].state = problem->ds_vecd;
 		task6->buffers[1].mode = R;
 
-	starpu_tag_declare_deps(maskiter | 6UL, 1, maskiter | 5UL);
+	starpu_tag_declare_deps((starpu_tag_t)(maskiter | 6UL), 1, (starpu_tag_t)(maskiter | 5UL));
 
 	/* r = r - alpha q */
 	struct starpu_task *task7 = create_task(maskiter | 7UL);
@@ -285,7 +285,7 @@ void launch_new_cg_iteration(struct cg_problem *problem)
 		task7->buffers[1].state = problem->ds_vecq;
 		task7->buffers[1].mode = R;
 
-	starpu_tag_declare_deps(maskiter | 7UL, 1, maskiter | 6UL);
+	starpu_tag_declare_deps((starpu_tag_t)(maskiter | 7UL), 1, (starpu_tag_t)(maskiter | 6UL));
 
 	/* update delta_* and compute beta */
 	struct starpu_task *task8 = create_task(maskiter | 8UL);
@@ -299,7 +299,7 @@ void launch_new_cg_iteration(struct cg_problem *problem)
 		task8->buffers[0].state = problem->ds_vecr;
 		task8->buffers[0].mode = R;
 
-	starpu_tag_declare_deps(maskiter | 8UL, 1, maskiter | 7UL);
+	starpu_tag_declare_deps((starpu_tag_t)(maskiter | 8UL), 1, (starpu_tag_t)(maskiter | 7UL));
 
 	/* d = r + beta d */
 	struct starpu_task *task9 = create_task(maskiter | 9UL);
@@ -315,7 +315,7 @@ void launch_new_cg_iteration(struct cg_problem *problem)
 		task9->buffers[1].state = problem->ds_vecr;
 		task9->buffers[1].mode = R;
 
-	starpu_tag_declare_deps(maskiter | 9UL, 1, maskiter | 8UL);
+	starpu_tag_declare_deps((starpu_tag_t)(maskiter | 9UL), 1, (starpu_tag_t)(maskiter | 8UL));
 
 	task9->callback_func = iteration_cg;
 	task9->callback_arg = problem;

examples/mult/dw_mult_no_stride.c

@@ -38,7 +38,7 @@ starpu_data_handle C_state[MAXSLICESY][MAXSLICESX];
 	(C[(i)/BLOCKSIZEY][(j)/BLOCKSIZEX][(i)%BLOCKSIZEY + ((j)%BLOCKSIZEX)*BLOCKSIZEY])
 
 #define TAG(x,y,z,iter)	\
-		((z) + (iter)*nslicesz + (x)*(nslicesz*niter) + (y)*(nslicesx*nslicesz*niter))
+		((starpu_tag_t)((z) + (iter)*nslicesz + (x)*(nslicesz*niter) + (y)*(nslicesx*nslicesz*niter)))
 
 static void submit_new_iter(unsigned x, unsigned y, unsigned iter);
 

examples/spmv/dw_block_spmv.c

@@ -193,7 +193,7 @@ void launch_spmv_codelets(void)
 				if (index != rowptr[row & ~0x3])
 				{
 					/* this is not the first task in the row */
-					starpu_tag_declare_deps(taskid, 1, taskid-1);
+					starpu_tag_declare_deps((starpu_tag_t)taskid, 1, (starpu_tag_t)(taskid-1));
 
 					is_entry_tab[taskid] = 0;
 				}

examples/strassen2/strassen2.c

@@ -253,7 +253,7 @@ struct starpu_task *compute_add_sub_op(starpu_data_handle C, enum operation op,
 	};
 
 	task->use_tag = 1;
-	task->tag_id = j_tag;
+	task->tag_id = (starpu_tag_t)j_tag;
 
 	return task;
 }
@@ -303,14 +303,14 @@ struct starpu_task *compute_self_add_sub_op(starpu_data_handle C, enum operation
 	};
 
 	task->use_tag = 1;
-	task->tag_id = j_tag;
+	task->tag_id = (starpu_tag_t)j_tag;
 
 	return task;
 }
 
 struct cleanup_arg {
 	unsigned ndeps;
-	uint64_t tags[8];
+	starpu_tag_t tags[8];
 	unsigned ndata;
 	starpu_data_handle data[32];
 };
@@ -364,9 +364,9 @@ void strassen_mult(struct strassen_iter *iter)
 	{
 		struct starpu_task *task_mult = 
 			compute_add_sub_op(iter->C, MULT, iter->A, iter->B);
-		uint64_t tag_mult = task_mult->tag_id;
+		starpu_tag_t tag_mult = task_mult->tag_id;
 
-		uint64_t deps_array[10];
+		starpu_tag_t deps_array[10];
 		unsigned indexA, indexB;
 		for (indexA = 0; indexA < iter->A_deps.ndeps; indexA++)
 		{
@@ -408,70 +408,70 @@ void strassen_mult(struct strassen_iter *iter)
 	/* M1a = (A11 + A22) */
 	iter->Mia_data[0] = allocate_tmp_matrix(size, iter->reclevel);
 	struct starpu_task *task_1a = compute_add_sub_op(iter->Mia_data[0], ADD, A11, A22);
-	uint64_t tag_1a = task_1a->tag_id;
+	starpu_tag_t tag_1a = task_1a->tag_id;
 	starpu_tag_declare_deps_array(tag_1a, iter->A_deps.ndeps, iter->A_deps.deps);
 	starpu_submit_task(task_1a);
 
 	/* M1b = (B11 + B22) */
 	iter->Mib_data[0] = allocate_tmp_matrix(size, iter->reclevel);
 	struct starpu_task *task_1b = compute_add_sub_op(iter->Mib_data[0], ADD, B11, B22);
-	uint64_t tag_1b = task_1b->tag_id;
+	starpu_tag_t tag_1b = task_1b->tag_id;
 	starpu_tag_declare_deps_array(tag_1b, iter->B_deps.ndeps, iter->B_deps.deps);
 	starpu_submit_task(task_1b);
 
 	/* M2a = (A21 + A22) */
 	iter->Mia_data[1] = allocate_tmp_matrix(size, iter->reclevel);
 	struct starpu_task *task_2a = compute_add_sub_op(iter->Mia_data[1], ADD, A21, A22);
-	uint64_t tag_2a = task_2a->tag_id;
+	starpu_tag_t tag_2a = task_2a->tag_id;
 	starpu_tag_declare_deps_array(tag_2a, iter->A_deps.ndeps, iter->A_deps.deps);
 	starpu_submit_task(task_2a);
 
 	/* M3b = (B12 - B22) */
 	iter->Mib_data[2] = allocate_tmp_matrix(size, iter->reclevel);
 	struct starpu_task *task_3b = compute_add_sub_op(iter->Mib_data[2], SUB, B12, B22);
-	uint64_t tag_3b = task_3b->tag_id;
+	starpu_tag_t tag_3b = task_3b->tag_id;
 	starpu_tag_declare_deps_array(tag_3b, iter->B_deps.ndeps, iter->B_deps.deps);
 	starpu_submit_task(task_3b);
 	
 	/* M4b = (B21 - B11) */
 	iter->Mib_data[3] = allocate_tmp_matrix(size, iter->reclevel);
 	struct starpu_task *task_4b = compute_add_sub_op(iter->Mib_data[3], SUB, B21, B11);
-	uint64_t tag_4b = task_4b->tag_id;
+	starpu_tag_t tag_4b = task_4b->tag_id;
 	starpu_tag_declare_deps_array(tag_4b, iter->B_deps.ndeps, iter->B_deps.deps);
 	starpu_submit_task(task_4b);
 	
 	/* M5a = (A11 + A12) */
 	iter->Mia_data[4] = allocate_tmp_matrix(size, iter->reclevel);
 	struct starpu_task *task_5a = compute_add_sub_op(iter->Mia_data[4], ADD, A11, A12);
-	uint64_t tag_5a = task_5a->tag_id;
+	starpu_tag_t tag_5a = task_5a->tag_id;
 	starpu_tag_declare_deps_array(tag_5a, iter->A_deps.ndeps, iter->A_deps.deps);
 	starpu_submit_task(task_5a);
 
 	/* M6a = (A21 - A11) */
 	iter->Mia_data[5] = allocate_tmp_matrix(size, iter->reclevel);
 	struct starpu_task *task_6a = compute_add_sub_op(iter->Mia_data[5], SUB, A21, A11);
-	uint64_t tag_6a = task_6a->tag_id;
+	starpu_tag_t tag_6a = task_6a->tag_id;
 	starpu_tag_declare_deps_array(tag_6a, iter->A_deps.ndeps, iter->A_deps.deps);
 	starpu_submit_task(task_6a);
 
 	/* M6b = (B11 + B12) */
 	iter->Mib_data[5] = allocate_tmp_matrix(size, iter->reclevel);
 	struct starpu_task *task_6b = compute_add_sub_op(iter->Mib_data[5], SUB, B11, B12);
-	uint64_t tag_6b = task_6b->tag_id;
+	starpu_tag_t tag_6b = task_6b->tag_id;
 	starpu_tag_declare_deps_array(tag_6b, iter->B_deps.ndeps, iter->B_deps.deps);
 	starpu_submit_task(task_6b);
 
 	/* M7a = (A12 - A22) */
 	iter->Mia_data[6] = allocate_tmp_matrix(size, iter->reclevel);
 	struct starpu_task *task_7a = compute_add_sub_op(iter->Mia_data[6], SUB, A12, A22);
-	uint64_t tag_7a = task_7a->tag_id;
+	starpu_tag_t tag_7a = task_7a->tag_id;
 	starpu_tag_declare_deps_array(tag_7a, iter->A_deps.ndeps, iter->A_deps.deps);
 	starpu_submit_task(task_7a);
 
 	/* M7b = (B21 + B22) */
 	iter->Mib_data[6] = allocate_tmp_matrix(size, iter->reclevel);
 	struct starpu_task *task_7b = compute_add_sub_op(iter->Mib_data[6], ADD, B21, B22);
-	uint64_t tag_7b = task_7b->tag_id;
+	starpu_tag_t tag_7b = task_7b->tag_id;
 	starpu_tag_declare_deps_array(tag_7b, iter->B_deps.ndeps, iter->B_deps.deps);
 	starpu_submit_task(task_7b);
 
@@ -501,7 +501,7 @@ void strassen_mult(struct strassen_iter *iter)
 	iter->children[1]->A_deps.ndeps = 1;
 	iter->children[1]->A_deps.deps[0] = tag_2a;
 	iter->children[1]->B_deps.ndeps = iter->B_deps.ndeps;
-	memcpy(iter->children[1]->B_deps.deps, iter->B_deps.deps, iter->B_deps.ndeps*sizeof(uint64_t));
+	memcpy(iter->children[1]->B_deps.deps, iter->B_deps.deps, iter->B_deps.ndeps*sizeof(starpu_tag_t));
 	iter->children[1]->A = iter->Mia_data[1]; 
 	iter->children[1]->B = B11; 
 	iter->children[1]->C = iter->Mi_data[1];
@@ -511,7 +511,7 @@ void strassen_mult(struct strassen_iter *iter)
 	iter->children[2] = malloc(sizeof(struct strassen_iter));
 	iter->children[2]->reclevel = iter->reclevel - 1;
 	iter->children[2]->A_deps.ndeps = iter->B_deps.ndeps;
-	memcpy(iter->children[2]->A_deps.deps, iter->A_deps.deps, iter->A_deps.ndeps*sizeof(uint64_t));
+	memcpy(iter->children[2]->A_deps.deps, iter->A_deps.deps, iter->A_deps.ndeps*sizeof(starpu_tag_t));
 	iter->children[2]->B_deps.ndeps = 1;
 	iter->children[2]->B_deps.deps[0] = tag_3b;
 	iter->children[2]->A = A11; 
@@ -523,7 +523,7 @@ void strassen_mult(struct strassen_iter *iter)
 	iter->children[3] = malloc(sizeof(struct strassen_iter));
 	iter->children[3]->reclevel = iter->reclevel - 1;
 	iter->children[3]->A_deps.ndeps = iter->B_deps.ndeps;
-	memcpy(iter->children[3]->A_deps.deps, iter->A_deps.deps, iter->A_deps.ndeps*sizeof(uint64_t));
+	memcpy(iter->children[3]->A_deps.deps, iter->A_deps.deps, iter->A_deps.ndeps*sizeof(starpu_tag_t));
 	iter->children[3]->B_deps.ndeps = 1;
 	iter->children[3]->B_deps.deps[0] = tag_4b;
 	iter->children[3]->A = A22; 
@@ -537,7 +537,7 @@ void strassen_mult(struct strassen_iter *iter)
 	iter->children[4]->A_deps.ndeps = 1;
 	iter->children[4]->A_deps.deps[0] = tag_5a;
 	iter->children[4]->B_deps.ndeps = iter->B_deps.ndeps;
-	memcpy(iter->children[4]->B_deps.deps, iter->B_deps.deps, iter->B_deps.ndeps*sizeof(uint64_t));
+	memcpy(iter->children[4]->B_deps.deps, iter->B_deps.deps, iter->B_deps.ndeps*sizeof(starpu_tag_t));
 	iter->children[4]->A = iter->Mia_data[4]; 
 	iter->children[4]->B = B22; 
 	iter->children[4]->C = iter->Mi_data[4];
@@ -567,13 +567,13 @@ void strassen_mult(struct strassen_iter *iter)
 	iter->children[6]->C = iter->Mi_data[6];
 	strassen_mult(iter->children[6]);
 
-	uint64_t *tag_m1 = iter->children[0]->C_deps.deps;
-	uint64_t *tag_m2 = iter->children[1]->C_deps.deps;
-	uint64_t *tag_m3 = iter->children[2]->C_deps.deps;
-	uint64_t *tag_m4 = iter->children[3]->C_deps.deps;
-	uint64_t *tag_m5 = iter->children[4]->C_deps.deps;
-	uint64_t *tag_m6 = iter->children[5]->C_deps.deps;
-	uint64_t *tag_m7 = iter->children[6]->C_deps.deps;
+	starpu_tag_t *tag_m1 = iter->children[0]->C_deps.deps;
+	starpu_tag_t *tag_m2 = iter->children[1]->C_deps.deps;
+	starpu_tag_t *tag_m3 = iter->children[2]->C_deps.deps;
+	starpu_tag_t *tag_m4 = iter->children[3]->C_deps.deps;
+	starpu_tag_t *tag_m5 = iter->children[4]->C_deps.deps;
+	starpu_tag_t *tag_m6 = iter->children[5]->C_deps.deps;
+	starpu_tag_t *tag_m7 = iter->children[6]->C_deps.deps;
 
 	/* C11 = M1 + M4 - M5 + M7 */
 	struct starpu_task *task_c11_a = compute_self_add_sub_op(C11, ADD, iter->Mi_data[0]);
@@ -581,24 +581,24 @@ void strassen_mult(struct strassen_iter *iter)
 	struct starpu_task *task_c11_c = compute_self_add_sub_op(C11, SUB, iter->Mi_data[4]);
 	struct starpu_task *task_c11_d = compute_self_add_sub_op(C11, ADD, iter->Mi_data[6]);
 
-	uint64_t tag_c11_a = task_c11_a->tag_id;
-	uint64_t tag_c11_b = task_c11_b->tag_id;
-	uint64_t tag_c11_c = task_c11_c->tag_id;
-	uint64_t tag_c11_d = task_c11_d->tag_id;
+	starpu_tag_t tag_c11_a = task_c11_a->tag_id;
+	starpu_tag_t tag_c11_b = task_c11_b->tag_id;
+	starpu_tag_t tag_c11_c = task_c11_c->tag_id;
+	starpu_tag_t tag_c11_d = task_c11_d->tag_id;
 
 	/* C12 = M3 + M5 */
 	struct starpu_task *task_c12_a = compute_self_add_sub_op(C12, ADD, iter->Mi_data[2]);
 	struct starpu_task *task_c12_b = compute_self_add_sub_op(C12, ADD, iter->Mi_data[4]);
 
-	uint64_t tag_c12_a = task_c12_a->tag_id;
-	uint64_t tag_c12_b = task_c12_b->tag_id;
+	starpu_tag_t tag_c12_a = task_c12_a->tag_id;
+	starpu_tag_t tag_c12_b = task_c12_b->tag_id;
 
 	/* C21 = M2 + M4 */
 	struct starpu_task *task_c21_a = compute_self_add_sub_op(C21, ADD, iter->Mi_data[1]);
 	struct starpu_task *task_c21_b = compute_self_add_sub_op(C21, ADD, iter->Mi_data[3]);
 
-	uint64_t tag_c21_a = task_c21_a->tag_id;
-	uint64_t tag_c21_b = task_c21_b->tag_id;
+	starpu_tag_t tag_c21_a = task_c21_a->tag_id;
+	starpu_tag_t tag_c21_b = task_c21_b->tag_id;
 
 	/* C22 = M1 - M2 + M3 + M6 */
 	struct starpu_task *task_c22_a = compute_self_add_sub_op(C22, ADD, iter->Mi_data[0]);
@@ -606,10 +606,10 @@ void strassen_mult(struct strassen_iter *iter)
 	struct starpu_task *task_c22_c = compute_self_add_sub_op(C22, ADD, iter->Mi_data[3]);
 	struct starpu_task *task_c22_d = compute_self_add_sub_op(C22, ADD, iter->Mi_data[5]);
 
-	uint64_t tag_c22_a = task_c22_a->tag_id;
-	uint64_t tag_c22_b = task_c22_b->tag_id;
-	uint64_t tag_c22_c = task_c22_c->tag_id;
-	uint64_t tag_c22_d = task_c22_d->tag_id;
+	starpu_tag_t tag_c22_a = task_c22_a->tag_id;
+	starpu_tag_t tag_c22_b = task_c22_b->tag_id;
+	starpu_tag_t tag_c22_c = task_c22_c->tag_id;
+	starpu_tag_t tag_c22_d = task_c22_d->tag_id;
 
 	if (iter->reclevel == 1)
 	{
@@ -714,7 +714,7 @@ static starpu_codelet dummy_codelet = {
 	.nbuffers = 0
 };
 
-static struct starpu_task *dummy_task(uint64_t tag)
+static struct starpu_task *dummy_task(starpu_tag_t tag)
 {
 	struct starpu_task *task =starpu_task_create();
 		task->callback_func = NULL;

examples/tag_example/tag_example.c

@@ -23,7 +23,7 @@
 
 #include <starpu.h>
 
-#define TAG(i, j, iter)	((uint64_t) ( ((uint64_t)(iter)<<48) |  ((uint64_t)(j)<<24) | (i)) )
+#define TAG(i, j, iter)	((starpu_tag_t) ( ((uint64_t)(iter)<<48) |  ((uint64_t)(j)<<24) | (i)) )
 
 sem_t sem;
 starpu_codelet cl;

examples/tag_example/tag_example2.c

@@ -23,7 +23,7 @@
 
 #include <starpu.h>
 
-#define TAG(i, iter)	((uint64_t)  (((uint64_t)iter)<<32 | (i)) )
+#define TAG(i, iter)	((starpu_tag_t)  (((uint64_t)iter)<<32 | (i)) )
 
 sem_t sem;
 starpu_codelet cl;

examples/tag_example/tag_example3.c

@@ -23,7 +23,7 @@
 
 #include <starpu.h>
 
-#define TAG(i, iter)	((uint64_t)  (((uint64_t)iter)<<32 | (i)) )
+#define TAG(i, iter)	((starpu_tag_t)  (((uint64_t)iter)<<32 | (i)) )
 
 sem_t sem;
 starpu_codelet cl;

include/starpu-task.h

@@ -137,8 +137,18 @@ void starpu_load_cuda_function(int devid, struct starpu_cuda_function_s *functio
 /* handle task dependencies: it is possible to associate a task with a unique
  * "tag" and to express dependencies among tasks by the means of those tags */
 void starpu_tag_remove(starpu_tag_t id);
-void starpu_tag_declare_deps_array(starpu_tag_t id, unsigned ndeps, starpu_tag_t *array);
+
+/*
+ * WARNING ! use with caution ...
+ *  In case starpu_tag_declare_deps is passed constant arguments, the caller
+ *  must make sure that the constants have the same size as starpu_tag_t.
+ *  Otherwise, nothing prevents the C compiler to consider the tag 0x20000003
+ *  instead of 0x2 and 0x3 when calling:
+ *      "starpu_tag_declare_deps(0x1, 2, 0x2, 0x3)"
+ *  Using starpu_tag_declare_deps_array is a way to avoid this problem.
+ */
 void starpu_tag_declare_deps(starpu_tag_t id, unsigned ndeps, ...);
+void starpu_tag_declare_deps_array(starpu_tag_t id, unsigned ndeps, starpu_tag_t *array);
 
 void starpu_tag_wait(starpu_tag_t id);
 void starpu_tag_wait_array(unsigned ntags, starpu_tag_t *id);

tests/microbenchs/tag-wait-api.c

@@ -56,20 +56,20 @@ static struct starpu_task *create_dummy_task(starpu_tag_t tag)
 	return task;
 }
 
-#define tagA	0x42
-#define tagB	0x12300
-
-#define tagC	0x32
-#define tagD	0x52
-#define tagE	0x19999
-#define tagF	0x2312
-#define tagG	0x1985
-
-#define tagH	0x32234
-#define tagI	0x5234
-#define tagJ	0x199
-#define tagK	0x231234
-#define tagL	0x2345
+#define tagA	((starpu_tag_t)0x42)
+#define tagB	((starpu_tag_t)0x12300)
+
+#define tagC	((starpu_tag_t)0x32)
+#define tagD	((starpu_tag_t)0x52)
+#define tagE	((starpu_tag_t)0x19999)
+#define tagF	((starpu_tag_t)0x2312)
+#define tagG	((starpu_tag_t)0x1985)
+
+#define tagH	((starpu_tag_t)0x32234)
+#define tagI	((starpu_tag_t)0x5234)
+#define tagJ	((starpu_tag_t)0x199)
+#define tagK	((starpu_tag_t)0x231234)
+#define tagL	((starpu_tag_t)0x2345)
 
 int main(int argc, char **argv)
 {