Add STARPU_CL_ARGS flag to starpu_task_insert() and starpu_mpi_task_insert() functions

ChangeLog

@@ -194,6 +194,8 @@ Small features:
     allows to copy in a new buffer values which have not been unpacked by
     the current call
   * Add STARPU_CODELET_SIMGRID_EXECUTE flag.
+  * Add STARPU_CL_ARGS flag to starpu_task_insert() and
+    starpu_mpi_task_insert() functions call
 
 Changes:
   * Data interfaces (variable, vector, matrix and block) now define

doc/doxygen/chapters/api/insert_task.doxy

@@ -31,8 +31,8 @@ specifying the worker on which to execute the task (as specified by
 starpu_task::execute_on_a_specific_worker)
 <li> the specific values ::STARPU_VALUE, ::STARPU_CALLBACK,
 ::STARPU_CALLBACK_ARG, ::STARPU_CALLBACK_WITH_ARG, ::STARPU_PRIORITY,
-::STARPU_TAG, ::STARPU_TAG_ONLY, ::STARPU_FLOPS, ::STARPU_SCHED_CTX followed by the
-appropriated objects as defined elsewhere.
+::STARPU_TAG, ::STARPU_TAG_ONLY, ::STARPU_FLOPS, ::STARPU_SCHED_CTX, ::STARPU_CL_ARGS
+followed by the appropriated objects as defined elsewhere.
 </ul>
 
 When using ::STARPU_DATA_ARRAY, the access mode of the data handles is
@@ -51,6 +51,13 @@ this macro is used when calling starpu_task_insert(), and must
 be followed by a pointer to a constant value and the size of the
 constant
 
+\def STARPU_CL_ARGS
+\ingroup API_Insert_Task
+this macro is used when calling starpu_task_insert(), and must
+be followed by a memory buffer containing the arguments to be given to
+the task, and by the size of the arguments. The memory buffer should
+be the result of a previous call to starpu_codelet_pack_args()
+
 \def STARPU_CALLBACK
 \ingroup API_Insert_Task
 this macro is used when calling starpu_task_insert(), and must

include/starpu_task_util.h

@@ -35,7 +35,7 @@ void starpu_create_sync_task(starpu_tag_t sync_tag, unsigned ndeps, starpu_tag_t
 /* NOTE: when adding a value here, please make sure to update both
  * src/util/starpu_task_insert_utils.c (in two places) and
  * mpi/src/starpu_mpi_task_insert.c */
-#define STARPU_MODE_SHIFT	16
+#define STARPU_MODE_SHIFT	17
 #define STARPU_VALUE		 (1<<STARPU_MODE_SHIFT)
 #define STARPU_CALLBACK		 (2<<STARPU_MODE_SHIFT)
 #define STARPU_CALLBACK_WITH_ARG (3<<STARPU_MODE_SHIFT)
@@ -59,7 +59,8 @@ void starpu_create_sync_task(starpu_tag_t sync_tag, unsigned ndeps, starpu_tag_t
 #define STARPU_WORKER_ORDER      (21<<STARPU_MODE_SHIFT)
 #define STARPU_NODE_SELECTION_POLICY (22<<STARPU_MODE_SHIFT)
 #define STARPU_NAME		 (23<<STARPU_MODE_SHIFT)
-#define STARPU_SHIFTED_MODE_MAX (24<<STARPU_MODE_SHIFT)
+#define STARPU_CL_ARGS		(24<<STARPU_MODE_SHIFT)
+#define STARPU_SHIFTED_MODE_MAX (25<<STARPU_MODE_SHIFT)
 
 struct starpu_task *starpu_task_build(struct starpu_codelet *cl, ...);
 int starpu_task_insert(struct starpu_codelet *cl, ...);

mpi/src/starpu_mpi_task_insert.c

@@ -318,6 +318,11 @@ int _starpu_mpi_task_decode_v(struct starpu_codelet *codelet, int me, int nb_nod
 			(void)va_arg(varg_list_copy, void *);
 			(void)va_arg(varg_list_copy, size_t);
 		}
+		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_CALLBACK)
 		{
 			(void)va_arg(varg_list_copy, _starpu_callback_func_t);

src/util/starpu_task_insert.c

@@ -95,16 +95,17 @@ static
 struct starpu_task *_starpu_task_build_v(struct starpu_codelet *cl, const char* task_name, int cl_arg_free, va_list varg_list)
 {
 	va_list varg_list_copy;
+	int ret;
 
 	struct starpu_task *task = starpu_task_create();
 	task->name = task_name;
 	task->cl_arg_free = cl_arg_free;
 
 	va_copy(varg_list_copy, varg_list);
-	_starpu_task_insert_create(cl, &task, varg_list_copy);
+	ret = _starpu_task_insert_create(cl, &task, varg_list_copy);
 	va_end(varg_list_copy);
 
-	return task;
+	return (ret == 0) ? task : NULL;
 }
 
 static
@@ -159,7 +160,7 @@ struct starpu_task *starpu_task_build(struct starpu_codelet *cl, ...)
 
 	va_start(varg_list, cl);
 	task = _starpu_task_build_v(cl, "task_build", 0, varg_list);
-	if (task->cl_arg)
+	if (task && task->cl_arg)
 	{
 		task->cl_arg_free = 1;
 }

src/util/starpu_task_insert_utils.c

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2011, 2013-2016   Université Bordeaux
- * Copyright (C) 2011-2015         CNRS
+ * Copyright (C) 2011-2016         CNRS
  * Copyright (C) 2011, 2014        INRIA
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -73,6 +73,11 @@ int _starpu_codelet_pack_args(void **arg_buffer, size_t *arg_buffer_size, va_lis
 			nargs++;
 			_starpu_pack_arguments(&current_offset, &_arg_buffer_size, &_arg_buffer, 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_CALLBACK)
 		{
 			(void)va_arg(varg_list, _starpu_callback_func_t);
@@ -205,7 +210,7 @@ void _starpu_task_insert_check_nb_buffers(struct starpu_codelet *cl, struct star
 	}
 }
 
-void _starpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task **task, va_list varg_list)
+int _starpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task **task, va_list varg_list)
 {
 	int arg_type;
 	char *arg_buffer_ = NULL;
@@ -315,6 +320,11 @@ void _starpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task **
 			nargs++;
 			_starpu_pack_arguments(&current_offset, &arg_buffer_size_, &arg_buffer_, ptr, ptr_size);
 		}
+		else if (arg_type==STARPU_CL_ARGS)
+		{
+			(*task)->cl_arg = va_arg(varg_list, void *);
+			(*task)->cl_arg_size = va_arg(varg_list, size_t);
+		}
 		else if (arg_type==STARPU_CALLBACK)
 		{
 			(*task)->callback_func = va_arg(varg_list, _starpu_callback_func_t);
@@ -436,6 +446,11 @@ void _starpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task **
 
 	if (nargs)
 	{
+		if ((*task)->cl_arg != NULL)
+		{
+			_STARPU_DISP("Parameters STARPU_CL_ARGS and STARPU_VALUE cannot be used in the same call\n");
+			return -EINVAL;
+		}
 		memcpy(arg_buffer_, (int *)&nargs, sizeof(nargs));
 		(*task)->cl_arg = arg_buffer_;
 		(*task)->cl_arg_size = arg_buffer_size_;
@@ -447,4 +462,5 @@ void _starpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task **
 	}
 
 	_STARPU_TRACE_TASK_BUILD_END();
+	return 0;
 }

src/util/starpu_task_insert_utils.h

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2011, 2012, 2013, 2014, 2015  CNRS
+ * Copyright (C) 2011, 2012, 2013, 2014, 2015, 2016  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
@@ -24,7 +24,7 @@
 typedef void (*_starpu_callback_func_t)(void *);
 
 int _starpu_codelet_pack_args(void **arg_buffer, size_t *arg_buffer_size, va_list varg_list);
-void _starpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task **task, va_list varg_list);
+int _starpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task **task, va_list varg_list);
 
 #endif // __STARPU_TASK_INSERT_UTILS_H__
 

tests/Makefile.am

@@ -1,7 +1,7 @@
 # StarPU --- Runtime system for heterogeneous multicore architectures.
 #
 # Copyright (C) 2009-2016  Université de Bordeaux
-# Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015  CNRS
+# Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016  CNRS
 # Copyright (C) 2010, 2011, 2012  INRIA
 #
 # StarPU is free software; you can redistribute it and/or modify
@@ -111,7 +111,8 @@ if STARPU_COVERAGE_ENABLED
 TESTS	+=	coverage/coverage.sh
 endif
 
-XFAIL_TESTS=	errorcheck/invalid_blocking_calls
+XFAIL_TESTS	=				\
+	errorcheck/invalid_blocking_calls
 
 noinst_PROGRAMS =				\
 	main/deprecated_func			\
@@ -122,6 +123,7 @@ noinst_PROGRAMS =				\
 	main/execute_on_a_specific_worker	\
 	main/execute_schedule			\
 	main/insert_task			\
+	main/insert_task_pack			\
 	main/insert_task_value			\
 	main/insert_task_dyn_handles		\
 	main/insert_task_nullcodelet		\

tests/main/insert_task_value.c

@@ -126,6 +126,35 @@ int do_test_int_float_task_insert(starpu_cpu_func_t func, char* func_name)
 	return 0;
 }
 
+int do_test_int_float_task_insert_pack(starpu_cpu_func_t func, char* func_name)
+{
+	int ifactor[2048];
+	float ffactor=FFACTOR;
+	int ret;
+	struct starpu_codelet codelet;
+	void *cl_arg = NULL;
+	size_t cl_arg_size = 0;
+
+	ifactor[0] = IFACTOR;
+
+	starpu_codelet_pack_args(&cl_arg, &cl_arg_size,
+				 STARPU_VALUE, ifactor, 2048*sizeof(ifactor[0]),
+				 STARPU_VALUE, &ffactor, sizeof(ffactor),
+				 0);
+
+	starpu_codelet_init(&codelet);
+	codelet.cpu_funcs[0] = func;
+	codelet.cpu_funcs_name[0] = func_name;
+
+	ret = starpu_task_insert(&codelet,
+				 STARPU_CL_ARGS, cl_arg, cl_arg_size,
+				 0);
+	if (ret == -ENODEV) return ret;
+	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
+	starpu_task_wait_for_all();
+	return 0;
+}
+
 int do_test_float_int_task_insert(starpu_cpu_func_t func, char* func_name)
 {
 	int ifactor[2048];
@@ -149,6 +178,35 @@ int do_test_float_int_task_insert(starpu_cpu_func_t func, char* func_name)
 	return 0;
 }
 
+int do_test_float_int_task_insert_pack(starpu_cpu_func_t func, char* func_name)
+{
+	int ifactor[2048];
+	float ffactor=FFACTOR;
+	int ret;
+	struct starpu_codelet codelet;
+	void *cl_arg = NULL;
+	size_t cl_arg_size = 0;
+
+	ifactor[0] = IFACTOR;
+
+	starpu_codelet_pack_args(&cl_arg, &cl_arg_size,
+				 STARPU_VALUE, &ffactor, sizeof(ffactor),
+				 STARPU_VALUE, ifactor, 2048*sizeof(ifactor[0]),
+				 0);
+
+	starpu_codelet_init(&codelet);
+	codelet.cpu_funcs[0] = func;
+	codelet.cpu_funcs_name[0] = func_name;
+
+	ret = starpu_task_insert(&codelet,
+				 STARPU_CL_ARGS, cl_arg, cl_arg_size,
+				 0);
+	if (ret == -ENODEV) return ret;
+	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
+	starpu_task_wait_for_all();
+	return 0;
+}
+
 int do_test_int_float_pack(starpu_cpu_func_t func, char* func_name)
 {
 	struct starpu_task *task;
@@ -206,14 +264,9 @@ int do_test_float_int_pack(starpu_cpu_func_t func, char* func_name)
 int main(int argc, char **argv)
 {
         int ret;
-	int ifactor[2048];
-	float ffactor=FFACTOR;
-	struct starpu_task *task;
 	(void) argc;
 	(void) argv;
 
-	ifactor[0] = IFACTOR;
-
 	ret = starpu_init(NULL);
 	if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
@@ -225,6 +278,13 @@ int main(int argc, char **argv)
 	ret = do_test_int_float_task_insert(func_cpu_int_float_unpack_copyleft, "func_cpu_int_float_unpack_copyleft");
 	if (ret == -ENODEV) goto enodev;
 
+	ret = do_test_int_float_task_insert_pack(func_cpu_int_float, "func_cpu_int_float_name");
+	if (ret == -ENODEV) goto enodev;
+	ret = do_test_int_float_task_insert_pack(func_cpu_int_float_multiple_unpack, "func_cpu_int_float_multiple_unpack");
+	if (ret == -ENODEV) goto enodev;
+	ret = do_test_int_float_task_insert_pack(func_cpu_int_float_unpack_copyleft, "func_cpu_int_float_unpack_copyleft");
+	if (ret == -ENODEV) goto enodev;
+
 	ret = do_test_float_int_task_insert(func_cpu_float_int, "func_cpu_float_int");
 	if (ret == -ENODEV) goto enodev;
 	ret = do_test_float_int_task_insert(func_cpu_float_int_multiple_unpack, "func_cpu_float_int_multiple_unpack");
@@ -232,6 +292,13 @@ int main(int argc, char **argv)
 	ret = do_test_float_int_task_insert(func_cpu_float_int_unpack_copyleft, "func_cpu_float_int_unpack_copyleft");
 	if (ret == -ENODEV) goto enodev;
 
+	ret = do_test_float_int_task_insert_pack(func_cpu_float_int, "func_cpu_float_int");
+	if (ret == -ENODEV) goto enodev;
+	ret = do_test_float_int_task_insert_pack(func_cpu_float_int_multiple_unpack, "func_cpu_float_int_multiple_unpack");
+	if (ret == -ENODEV) goto enodev;
+	ret = do_test_float_int_task_insert_pack(func_cpu_float_int_unpack_copyleft, "func_cpu_float_int_unpack_copyleft");
+	if (ret == -ENODEV) goto enodev;
+
 	ret = do_test_int_float_pack(func_cpu_int_float, "func_cpu_int_float_name");
 	if (ret == -ENODEV) goto enodev;
 	ret = do_test_int_float_pack(func_cpu_int_float_multiple_unpack, "func_cpu_int_float_multiple_unpack");