doc: minor fixes for starpu_insert_task

doc/starpu.texi

@@ -1236,8 +1236,8 @@ transfers, which are assumed to be completely overlapped.
 @node Insert Task Utility
 @section Insert Task Utility
 
-StarPU provides the function @code{starpu_insert_task} to ease the
-creation and submission of tasks. 
+StarPU provides the wrapper function @code{starpu_insert_task} to ease
+the creation and submission of tasks.
 
 @emph{Prototype}:
 @code{int starpu_insert_task(starpu_codelet *cl, ...);}
@@ -1247,12 +1247,13 @@ The arguments following the codelets can be of the following types:
 @item
 @code{STARPU_R}, @code{STARPU_W}, @code{STARPU_RW}, @code{STARPU_SCRATCH} an access mode followed by a data handle;
 @item
-@code{STARPU_VALUE} followed  by a pointer to the constant value and
+@code{STARPU_VALUE} followed  by a pointer to a constant value and
 the size of the constant;
 @item
-@code{STARPU_CALLBACK} followed by pointer to a function;
+@code{STARPU_CALLBACK} followed by a pointer to a callback function;
 @item
-@code{STARPU_CALLBACK_ARG} followed by a pointer;
+@code{STARPU_CALLBACK_ARG} followed by a pointer to be given as an
+argument to the callback function;
 @item
 @code{STARPU_PRIORITY} followed by a integer defining a priority level.
 @end itemize

src/util/starpu_insert_task.c

@@ -23,6 +23,61 @@
 #include <stdarg.h>
 #include <util/starpu_insert_task_utils.h>
 
+void starpu_pack_cl_args(va_list varg_list)
+{
+	va_list varg_list;
+
+	/* TODO use a single malloc to allocate the memory for arg_buffer and
+	 * the callback argument wrapper */
+	char *arg_buffer = malloc(arg_buffer_size);
+	STARPU_ASSERT(arg_buffer);
+	unsigned current_arg_offset = 0;
+
+	/* We will begin the buffer with the number of args (which is stored as a char) */
+	current_arg_offset += sizeof(char);
+
+	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 cst_size = va_arg(varg_list, size_t);
+
+			*(size_t *)(&arg_buffer[current_arg_offset]) = cst_size;
+			current_arg_offset += sizeof(size_t);
+
+			memcpy(&arg_buffer[current_arg_offset], ptr, cst_size);
+			current_arg_offset += cst_size;
+
+			nargs++;
+			STARPU_ASSERT(current_arg_offset <= arg_buffer_size);
+		}
+		else if (arg_type==STARPU_R || arg_type==STARPU_W || arg_type==STARPU_RW || arg_type == STARPU_SCRATCH)
+		{
+			/* We have an access mode : we expect to find a handle */
+			va_arg(varg_list, starpu_data_handle);
+		}
+		else if (arg_type==STARPU_CALLBACK)
+		{
+			va_arg(varg_list, void (*)(void *));
+		}
+		else if (arg_type==STARPU_CALLBACK_ARG) {
+			va_arg(varg_list, void *);
+		}
+		else if (arg_type==STARPU_PRIORITY)
+		{
+			va_arg(varg_list, int); 
+		}
+		else if (arg_type==STARPU_EXECUTE) {
+			va_arg(varg_list, int);
+		}
+	}
+	arg_buffer[0] = nargs;
+
+	va_end(varg_list);
+}
+
 void starpu_unpack_cl_args(void *_cl_arg, ...)
 {
 	unsigned char *cl_arg = _cl_arg;
@@ -56,14 +111,10 @@ void starpu_insert_task(starpu_codelet *cl, ...)
 
 	/* The buffer will contain : nargs, {size, content} (x nargs)*/
 
-	/* Compute the size */
-	size_t arg_buffer_size = 0;
-
 	va_start(varg_list, cl);
-        arg_buffer_size = starpu_insert_task_get_arg_size(varg_list);
+        starpu_pack_cl_args(varg_list);
 
 	va_start(varg_list, cl);
         struct starpu_task *task = starpu_task_create();
         starpu_insert_task_create_and_submit(arg_buffer_size, cl, &task, varg_list);
-
 }

src/util/starpu_insert_task_utils.c

@@ -39,7 +39,7 @@ void starpu_task_insert_callback_wrapper(void *_cl_arg_wrapper)
 	free(cl_arg_wrapper->arg_stack);
 }
 
-size_t starpu_insert_task_get_arg_size(va_list varg_list)
+int starpu_pack_cl_args(va_list varg_list)
 {
 	int arg_type;
         size_t arg_buffer_size;
@@ -77,20 +77,11 @@ size_t starpu_insert_task_get_arg_size(va_list varg_list)
         return arg_buffer_size;
 }
 
-int starpu_insert_task_create_and_submit(size_t arg_buffer_size, starpu_codelet *cl, struct starpu_task **task, va_list varg_list) {
+int starpu_insert_task_create_and_submit(char *arg_buffer, starpu_codelet *cl, struct starpu_task **task, va_list varg_list) {
         int arg_type;
 	unsigned current_buffer = 0;
 	unsigned char nargs = 0;
 
-	/* TODO use a single malloc to allocate the memory for arg_buffer and
-	 * the callback argument wrapper */
-	char *arg_buffer = malloc(arg_buffer_size);
-	STARPU_ASSERT(arg_buffer);
-	unsigned current_arg_offset = 0;
-
-	/* We will begin the buffer with the number of args (which is stored as a char) */
-	current_arg_offset += sizeof(char);
-
 	struct insert_task_cb_wrapper *cl_arg_wrapper = malloc(sizeof(struct insert_task_cb_wrapper));
 	STARPU_ASSERT(cl_arg_wrapper);
 
@@ -113,18 +104,8 @@ int starpu_insert_task_create_and_submit(size_t arg_buffer_size, starpu_codelet
 		}
 		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 cst_size = va_arg(varg_list, size_t);
-
-			*(size_t *)(&arg_buffer[current_arg_offset]) = cst_size;
-			current_arg_offset += sizeof(size_t);
-
-			memcpy(&arg_buffer[current_arg_offset], ptr, cst_size);
-			current_arg_offset += cst_size;
-
-			nargs++;
-			STARPU_ASSERT(current_arg_offset <= arg_buffer_size);
+			va_arg(varg_list, void *);
+			va_arg(varg_list, size_t);
 		}
 		else if (arg_type==STARPU_CALLBACK)
 		{
@@ -148,9 +129,6 @@ int starpu_insert_task_create_and_submit(size_t arg_buffer_size, starpu_codelet
 	}
 
 	va_end(varg_list);
-
-	arg_buffer[0] = nargs;
-
 	STARPU_ASSERT(current_buffer == cl->nbuffers);
 
 	(*task)->cl = cl;