stress task_insert even more

include/starpu_task.h

@@ -25,6 +25,7 @@
 #include <starpu_util.h>
 #include <starpu_task_bundle.h>
 #include <errno.h>
+#include <assert.h>
 
 #if defined STARPU_USE_CUDA && !defined STARPU_DONT_INCLUDE_CUDA_HEADERS
 # include <cuda.h>
@@ -244,7 +245,7 @@ struct starpu_task
 #define STARPU_TASK_GET_HANDLES(task) (((task)->dyn_handles) ? (task)->dyn_handles : (task)->handles)
 #define STARPU_TASK_SET_HANDLE(task, handle, i) do { if ((task)->dyn_handles) (task)->dyn_handles[i] = handle; else (task)->handles[i] = handle; } while(0)
 
-#define STARPU_CODELET_GET_MODE(codelet, i) (((codelet)->dyn_modes) ? (codelet)->dyn_modes[i] : (codelet)->modes[i])
+#define STARPU_CODELET_GET_MODE(codelet, i) (((codelet)->dyn_modes) ? (codelet)->dyn_modes[i] : (assert(i < STARPU_NMAXBUFS), (codelet)->modes[i]))
 #define STARPU_CODELET_SET_MODE(codelet, mode, i) do { if ((codelet)->dyn_modes) (codelet)->dyn_modes[i] = mode; else (codelet)->modes[i] = mode; } while(0)
 
 #define STARPU_TASK_GET_MODE(task, i) ((task)->cl->nbuffers == STARPU_VARIABLE_NBUFFERS || (task)->dyn_modes ? \

mpi/src/starpu_mpi_task_insert.c

@@ -260,6 +260,7 @@ int _starpu_mpi_task_decode_v(struct starpu_codelet *codelet, int me, int nb_nod
 
 			for(i=0 ; i<nb_handles ; i++)
 			{
+				STARPU_ASSERT_MSG(cl->nbuffers == STARPU_VARIABLE_NBUFFERS || nb_data < cl->nbuffers, "Too many data passed to starpu_mpi_task_insert");
 				enum starpu_data_access_mode mode = STARPU_CODELET_GET_MODE(codelet, nb_data);
 				if (node_selected == 0)
 				{

src/util/starpu_task_insert_utils.c

@@ -261,6 +261,7 @@ void _starpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task **
 			/* We have an access mode : we expect to find a handle */
 			starpu_data_handle_t handle = va_arg(varg_list, starpu_data_handle_t);
 			enum starpu_data_access_mode mode = (enum starpu_data_access_mode) arg_type & ~STARPU_SSEND;
+			STARPU_ASSERT_MSG(cl->nbuffers == STARPU_VARIABLE_NBUFFERS || current_buffer < cl->nbuffers, "Too many data passed to starpu_task_insert");
 
 			STARPU_ASSERT(cl != NULL);
 
@@ -315,6 +316,7 @@ void _starpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task **
 			int i;
 			for(i=0 ; i<nb_descrs ; i++)
 			{
+				STARPU_ASSERT_MSG(cl->nbuffers == STARPU_VARIABLE_NBUFFERS || current_buffer < cl->nbuffers, "Too many data passed to starpu_task_insert");
 				_starpu_task_insert_check_nb_buffers(cl, task, &allocated_buffers, current_buffer);
 				STARPU_TASK_SET_HANDLE((*task), descrs[i].handle, current_buffer);
 				if ((*task)->dyn_modes)

tests/Makefile.am

@@ -122,6 +122,7 @@ noinst_PROGRAMS =				\
 	main/insert_task_dyn_handles		\
 	main/insert_task_nullcodelet		\
 	main/insert_task_array			\
+	main/insert_task_many			\
 	main/multithreaded			\
 	main/multithreaded_init			\
 	main/starpu_task_bundle			\

tests/main/insert_task_dyn_handles.c

@@ -48,6 +48,22 @@ struct starpu_codelet codelet_minus1 =
 	.nbuffers = STARPU_NMAXBUFS-1,
 };
 
+struct starpu_codelet codelet_exactly =
+{
+	.cpu_funcs = {func_cpu},
+	/* starpu_task_get_current() doesn't work on MIC */
+	/* .cpu_funcs_name = {"func_cpu"}, */
+	.nbuffers = STARPU_NMAXBUFS,
+};
+
+struct starpu_codelet codelet_plus1 =
+{
+	.cpu_funcs = {func_cpu},
+	/* starpu_task_get_current() doesn't work on MIC */
+	/* .cpu_funcs_name = {"func_cpu"}, */
+	.nbuffers = STARPU_NMAXBUFS+1,
+};
+
 struct starpu_codelet codelet_plus5 =
 {
 	.cpu_funcs = {func_cpu},
@@ -56,6 +72,59 @@ struct starpu_codelet codelet_plus5 =
 	.nbuffers = STARPU_NMAXBUFS+5,
 };
 
+starpu_data_handle_t *data_handles;
+struct starpu_data_descr *descrs;
+int *expected;
+
+int test(int n, struct starpu_codelet *static_codelet)
+{
+	int i, ret;
+
+	for (i = 0; i < n; i++)
+		expected[i]++;
+	ret = starpu_task_insert(&codelet,
+				 STARPU_DATA_MODE_ARRAY, descrs, n,
+				 0);
+	if (ret == -ENODEV) return ret;
+	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
+
+	/* Same with static number of buffers in codelet */
+	for (i = 0; i < n; i++)
+		expected[i]++;
+	ret = starpu_task_insert(static_codelet,
+				 STARPU_DATA_MODE_ARRAY, descrs, n,
+				 0);
+	if (ret == -ENODEV) return ret;
+	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
+
+	/* Test a whole array after one data */
+	expected[0]++;
+	for (i = 1; i < n; i++)
+		expected[i]++;
+	ret = starpu_task_insert(&codelet,
+				 STARPU_RW, data_handles[0],
+				 STARPU_DATA_MODE_ARRAY, &descrs[1], n-1,
+				 0);
+	if (ret == -ENODEV) return ret;
+	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
+
+	if (n > 1)
+	{
+		/* Same with static number of buffers in codelet */
+		expected[0]++;
+		for (i = 1; i < n; i++)
+			expected[i]++;
+		ret = starpu_task_insert(static_codelet,
+					 STARPU_RW, data_handles[0],
+					 STARPU_DATA_MODE_ARRAY, &descrs[1], n-1,
+					 0);
+		if (ret == -ENODEV) return ret;
+		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
+	}
+
+	return 0;
+}
+
 int main(int argc, char **argv)
 {
         int *x;
@@ -66,9 +135,6 @@ int main(int argc, char **argv)
 #else
 	int nloops = 16;
 #endif
-        starpu_data_handle_t *data_handles;
-	struct starpu_data_descr *descrs;
-	int *expected;
 
 	ret = starpu_init(NULL);
 	if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
@@ -87,84 +153,17 @@ int main(int argc, char **argv)
 
 	for (loop = 0; loop < nloops; loop++)
 	{
-		/* Test a whole array but smaller than NMAXBUFS */
-		for (i = 0; i < STARPU_NMAXBUFS-1; i++)
-			expected[i]++;
-		ret = starpu_task_insert(&codelet,
-					 STARPU_DATA_MODE_ARRAY, descrs, STARPU_NMAXBUFS-1,
-					 0);
-		if (ret == -ENODEV) goto enodev;
-		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
-
-		/* Same with static number of buffers in codelet */
-		for (i = 0; i < STARPU_NMAXBUFS-1; i++)
-			expected[i]++;
-		ret = starpu_task_insert(&codelet_minus1,
-					 STARPU_DATA_MODE_ARRAY, descrs, STARPU_NMAXBUFS-1,
-					 0);
-		if (ret == -ENODEV) goto enodev;
-		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
-
-		/* Test a whole array after one data, but smaller than NMAXBUFS */
-		expected[0]++;
-		for (i = 1; i < STARPU_NMAXBUFS-1; i++)
-			expected[i]++;
-		ret = starpu_task_insert(&codelet,
-					 STARPU_RW, data_handles[0],
-					 STARPU_DATA_MODE_ARRAY, &descrs[1], STARPU_NMAXBUFS-2,
-					 0);
-		if (ret == -ENODEV) goto enodev;
-		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
-
-#if STARPU_NMAXBUFS > 1
-		/* Same with static number of buffers in codelet */
-		expected[0]++;
-		for (i = 1; i < STARPU_NMAXBUFS-1; i++)
-			expected[i]++;
-		ret = starpu_task_insert(&codelet_minus1,
-					 STARPU_RW, data_handles[0],
-					 STARPU_DATA_MODE_ARRAY, &descrs[1], STARPU_NMAXBUFS-2,
-					 0);
-		if (ret == -ENODEV) goto enodev;
+		/* Test smaller than NMAXBUFS */
+		ret = test(STARPU_NMAXBUFS-1, &codelet_minus1);
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
-#endif
-
-		/* Test a whole array bigger than NMAXBUFS */
-		for (i = 0; i < STARPU_NMAXBUFS+5; i++)
-			expected[i]++;
-		ret = starpu_task_insert(&codelet,
-					 STARPU_DATA_MODE_ARRAY, descrs, STARPU_NMAXBUFS+5,
-					 0);
-		if (ret == -ENODEV) goto enodev;
-		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
-
-		/* Same with static number of buffers in codelet */
-		for (i = 0; i < STARPU_NMAXBUFS+5; i++)
-			expected[i]++;
-		ret = starpu_task_insert(&codelet_plus5,
-					 STARPU_DATA_MODE_ARRAY, descrs, STARPU_NMAXBUFS+5,
-					 0);
-		if (ret == -ENODEV) goto enodev;
+		/* Test exactly NMAXBUFS */
+		ret = test(STARPU_NMAXBUFS, &codelet_exactly);
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
-
-		/* Test a whole array after one data, and bigger than NMAXBUFS */
-		for (i = 0; i < STARPU_NMAXBUFS+5; i++)
-			expected[i]++;
-		ret = starpu_task_insert(&codelet,
-					 STARPU_RW, data_handles[0],
-					 STARPU_DATA_MODE_ARRAY, &descrs[1], STARPU_NMAXBUFS+4,
-					 0);
-		if (ret == -ENODEV) goto enodev;
+		/* Test more than NMAXBUFS */
+		ret = test(STARPU_NMAXBUFS+1, &codelet_plus1);
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
-
-		/* Same with static number of buffers in codelet */
-		for (i = 0; i < STARPU_NMAXBUFS+5; i++)
-			expected[i]++;
-		ret = starpu_task_insert(&codelet_plus5,
-					 STARPU_RW, data_handles[0],
-					 STARPU_DATA_MODE_ARRAY, &descrs[1], STARPU_NMAXBUFS+4,
-					 0);
-		if (ret == -ENODEV) goto enodev;
+		/* Test yet more than NMAXBUFS */
+		ret = test(STARPU_NMAXBUFS+5, &codelet_plus5);
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
 
 		/* Test datas one after the other, but less than NMAXBUFS */
@@ -234,7 +233,10 @@ int main(int argc, char **argv)
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
 #endif
 
-		/* Test datas one after the other, but less than NMAXBUFS */
+
+
+
+		/* Test datas one after the other, but more than NMAXBUFS */
 		for (i = 0; i < STARPU_NMAXBUFS+5 && i < 10; i++)
 			expected[i]++;
 		ret = starpu_task_insert(&codelet,

tests/main/insert_task_many.c

@@ -0,0 +1,239 @@
+/* StarPU --- Runtime system for heterogeneous multicore architectures.
+ *
+ * Copyright (C) 2011, 2012, 2013, 2014  CNRS
+ *
+ * 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 <config.h>
+#include <starpu.h>
+#include <starpu_config.h>
+#include "../helper.h"
+
+#define NPARAMS 15
+
+void func_cpu(void *descr[], void *_args STARPU_ATTRIBUTE_UNUSED)
+{
+	struct starpu_task *task = starpu_task_get_current();
+	int num = STARPU_TASK_GET_NBUFFERS(task);
+	int i;
+
+	for (i = 0; i < num; i++)
+		if ((STARPU_TASK_GET_MODE(task, i) & STARPU_W)
+		 || (STARPU_TASK_GET_MODE(task, i) & STARPU_SCRATCH))
+		{
+			int *x = (int *)STARPU_VARIABLE_GET_PTR(descr[i]);
+
+			*x = *x + 1;
+		}
+}
+
+/* We will fill this one with dyn_modes */
+struct starpu_codelet codelet_dyn =
+{
+	.cpu_funcs = {func_cpu},
+	/* starpu_task_get_current() doesn't work on MIC */
+	/* .cpu_funcs_name = {"func_cpu"}, */
+	.nbuffers = NPARAMS,
+};
+
+/* This will warn out at compilation time when maxbuffers is less than NPARAMS.
+ * That is on purpose: we here check that we still behave correctly in that case.
+ * We are just not able to check the parameter access modes.  */
+struct starpu_codelet codelet_toomany =
+{
+	.cpu_funcs = {func_cpu},
+	/* starpu_task_get_current() doesn't work on MIC */
+	/* .cpu_funcs_name = {"func_cpu"}, */
+	.nbuffers = NPARAMS,
+	.modes = {
+		STARPU_R,
+		STARPU_R,
+		STARPU_RW|STARPU_COMMUTE,
+		STARPU_RW|STARPU_COMMUTE,
+		STARPU_R,
+		STARPU_RW,
+		STARPU_R,
+		STARPU_RW|STARPU_COMMUTE,
+		STARPU_R,
+		STARPU_RW|STARPU_COMMUTE,
+		STARPU_R,
+		STARPU_R,
+		STARPU_SCRATCH,
+		STARPU_SCRATCH,
+		STARPU_SCRATCH,
+	}
+};
+
+struct starpu_codelet codelet_variable =
+{
+	.cpu_funcs = {func_cpu},
+	/* starpu_task_get_current() doesn't work on MIC */
+	/* .cpu_funcs_name = {"func_cpu"}, */
+	.nbuffers = STARPU_VARIABLE_NBUFFERS,
+};
+
+int main(int argc, char **argv)
+{
+        int *x;
+        int i, ret, loop;
+
+#ifdef STARPU_QUICK_CHECK
+	int nloops = 4;
+#else
+	int nloops = 16;
+#endif
+	int val_int = 42;
+	double val_double = 42.;
+        starpu_data_handle_t *data_handles;
+	int *expected;
+
+	ret = starpu_init(NULL);
+	if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
+	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
+
+	codelet_dyn.dyn_modes = malloc(NPARAMS * sizeof(*(codelet_dyn.modes)));
+	codelet_dyn.dyn_modes[0] = STARPU_R,
+	codelet_dyn.dyn_modes[1] = STARPU_R,
+	codelet_dyn.dyn_modes[2] = STARPU_RW|STARPU_COMMUTE,
+	codelet_dyn.dyn_modes[3] = STARPU_RW|STARPU_COMMUTE,
+	codelet_dyn.dyn_modes[4] = STARPU_R,
+	codelet_dyn.dyn_modes[5] = STARPU_RW,
+	codelet_dyn.dyn_modes[6] = STARPU_R,
+	codelet_dyn.dyn_modes[7] = STARPU_RW|STARPU_COMMUTE,
+	codelet_dyn.dyn_modes[8] = STARPU_R,
+	codelet_dyn.dyn_modes[9] = STARPU_RW|STARPU_COMMUTE,
+	codelet_dyn.dyn_modes[10] = STARPU_R,
+	codelet_dyn.dyn_modes[11] = STARPU_R,
+	codelet_dyn.dyn_modes[12] = STARPU_SCRATCH,
+	codelet_dyn.dyn_modes[13] = STARPU_SCRATCH,
+	codelet_dyn.dyn_modes[14] = STARPU_SCRATCH,
+
+	x = calloc(NPARAMS, sizeof(*x));
+	data_handles = malloc(NPARAMS * sizeof(*data_handles));
+	expected = calloc(NPARAMS, sizeof(*expected));
+	for(i=0 ; i<NPARAMS ; i++)
+		starpu_variable_data_register(&data_handles[i], STARPU_MAIN_RAM, (uintptr_t)&x[i], sizeof(x[i]));
+
+	for (loop = 0; loop < nloops; loop++)
+	{
+		for (i = 0; i < NPARAMS; i++)
+			if ((codelet_dyn.dyn_modes[i] & STARPU_W))
+				expected[i]++;
+		ret = starpu_task_insert(&codelet_dyn,
+					 STARPU_R, data_handles[0],
+					 STARPU_R, data_handles[1],
+					 STARPU_RW|STARPU_COMMUTE, data_handles[2],
+					 STARPU_RW|STARPU_COMMUTE, data_handles[3],
+					 STARPU_R, data_handles[4],
+					 STARPU_RW, data_handles[5],
+					 STARPU_R, data_handles[6],
+					 STARPU_RW|STARPU_COMMUTE, data_handles[7],
+					 STARPU_R, data_handles[8],
+					 STARPU_RW|STARPU_COMMUTE, data_handles[9],
+					 STARPU_R, data_handles[10],
+					 STARPU_R, data_handles[11],
+					 STARPU_SCRATCH, data_handles[12],
+					 STARPU_SCRATCH, data_handles[13],
+					 STARPU_SCRATCH, data_handles[14],
+					 0);
+		if (ret == -ENODEV) goto enodev;
+		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
+
+		/* Same, but using the toomany codelet */
+		for (i = 0; i < NPARAMS; i++)
+			if ((codelet_dyn.dyn_modes[i] & STARPU_W))
+				expected[i]++;
+		ret = starpu_task_insert(&codelet_toomany,
+					 STARPU_R, data_handles[0],
+					 STARPU_R, data_handles[1],
+					 STARPU_RW|STARPU_COMMUTE, data_handles[2],
+					 STARPU_RW|STARPU_COMMUTE, data_handles[3],
+					 STARPU_R, data_handles[4],
+					 STARPU_RW, data_handles[5],
+					 STARPU_R, data_handles[6],
+					 STARPU_RW|STARPU_COMMUTE, data_handles[7],
+					 STARPU_R, data_handles[8],
+					 STARPU_RW|STARPU_COMMUTE, data_handles[9],
+					 STARPU_R, data_handles[10],
+					 STARPU_R, data_handles[11],
+					 STARPU_SCRATCH, data_handles[12],
+					 STARPU_SCRATCH, data_handles[13],
+					 STARPU_SCRATCH, data_handles[14],
+					 0);
+		if (ret == -ENODEV) goto enodev;
+		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
+
+		/* Same, but using the variable codelet */
+		for (i = 0; i < NPARAMS; i++)
+			if ((codelet_dyn.dyn_modes[i] & STARPU_W))
+				expected[i]++;
+		ret = starpu_task_insert(&codelet_variable,
+					 STARPU_R, data_handles[0],
+					 STARPU_R, data_handles[1],
+					 STARPU_RW|STARPU_COMMUTE, data_handles[2],
+					 STARPU_RW|STARPU_COMMUTE, data_handles[3],
+					 STARPU_R, data_handles[4],
+					 STARPU_RW, data_handles[5],
+					 STARPU_R, data_handles[6],
+					 STARPU_RW|STARPU_COMMUTE, data_handles[7],
+					 STARPU_R, data_handles[8],
+					 STARPU_RW|STARPU_COMMUTE, data_handles[9],
+					 STARPU_R, data_handles[10],
+					 STARPU_R, data_handles[11],
+					 STARPU_SCRATCH, data_handles[12],
+					 STARPU_SCRATCH, data_handles[13],
+					 STARPU_SCRATCH, data_handles[14],
+					 0);
+		if (ret == -ENODEV) goto enodev;
+		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
+
+	}
+
+enodev:
+        for(i=0 ; i<NPARAMS ; i++)
+	{
+                starpu_data_unregister(data_handles[i]);
+        }
+
+	starpu_shutdown();
+	free(data_handles);
+	free(codelet_dyn.dyn_modes);
+
+	if (ret == -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 */
+		free(x);
+		free(expected);
+		return STARPU_TEST_SKIPPED;
+	}
+	else
+	{
+		for(i=0 ; i<NPARAMS; i++)
+		{
+			if (x[i] != expected[i])
+			{
+				FPRINTF(stderr, "[end loop] value[%d] = %d != Expected value %d\n", i, x[i], expected[i]);
+				ret = 1;
+			}
+		}
+		if (ret == 0)
+		{
+			FPRINTF(stderr, "[end of loop] all values are correct\n");
+		}
+		free(x);
+		free(expected);
+		return ret;
+	}
+}