documentation and test for starpu_codelet_unpack_arg_init() & co

include/starpu_task_util.h

@@ -486,6 +486,12 @@ void starpu_task_insert_data_process_mode_array_arg(struct starpu_codelet *cl, s
 */
 void starpu_codelet_pack_args(void **arg_buffer, size_t *arg_buffer_size, ...);
 
+/**
+   Structure to be used for starpu_codelet_pack_arg_init() & co, and
+   starpu_codelet_unpack_arg_init() & co. The contents is public,
+   however users should not directly access it, but only use as a
+   parameter to the appropriate functions.
+*/
 struct starpu_codelet_pack_arg_data
 {
 	char *arg_buffer;
@@ -526,35 +532,39 @@ void starpu_codelet_pack_arg_fini(struct starpu_codelet_pack_arg_data *state, vo
 void starpu_codelet_unpack_args(void *cl_arg, ...);
 
 /**
-   Initialize \p state before calling starpu_codelet_unpack_arg().
-   This will pass \p cl_arg and \p cl_arg_size the content of struct starpu_codelet_pack_arg_data.
+   Initialize \p state with \p cl_arg and \p cl_arg_size. This has to
+   be called before calling starpu_codelet_unpack_arg().
 */
-void starpu_codelet_unpack_arg_init(struct starpu_codelet_pack_arg_data *state, void **cl_arg, size_t *cl_arg_size);
+void starpu_codelet_unpack_arg_init(struct starpu_codelet_pack_arg_data *state, void *cl_arg, size_t cl_arg_size);
 
 /**
-   Unpack one argument from struct starpu_codelet_pack_arg \p state into ptr with a copy.
-   That structure has to be initialized before with starpu_codelet_unpack_arg_init().
-   Size is stored in starpu_task->cl_arg, and it is a known parameter in this function .
+   Unpack the next argument of size \p size from \p state into \p ptr with a copy.
+   \p state has to be initialized before with starpu_codelet_unpack_arg_init().
 */
 void starpu_codelet_unpack_arg(struct starpu_codelet_pack_arg_data *state, void *ptr, size_t size);
 
 /**
-   Unpack one argument from struct starpu_codelet_pack_arg \p state into ptr with a copy.
-   That structure has to be initialized before with starpu_codelet_unpack_arg_init().
-   Size is stored in starpu_task->cl_arg, and it is an unknown parameter in this function.
-   It will be returned from starpu_task->cl_arg with a copy.
+   Unpack the next argument of unknown size from \p state into \p ptr
+   with a copy. \p ptr is allocated before copying in it the value of
+   the argument.
+   The size of the argument is returned in \p size.
+   \p has to be initialized before with starpu_codelet_unpack_arg_init().
 */
 void starpu_codelet_dup_arg(struct starpu_codelet_pack_arg_data *state, void **ptr, size_t *size);
 
 /**
-   Unpack one argument from struct starpu_codelet_pack_arg \p state
-   into ptr, and the pointer of ptr will be returned.
-   That structure has to be initialized before with starpu_codelet_unpack_arg_init().
-   Size is stored in starpu_task->cl_arg, and it is an unknown parameter in this function.
-   It will be returned from starpu_task->cl_arg with a copy.
+   Unpack the next argument of unknown size from \p state into \p ptr.
+   \p ptr will be a pointer to the memory of the argument.
+   The size of the argument is returned in \p size.
+   \p has to be initialized before with starpu_codelet_unpack_arg_init().
 */
 void starpu_codelet_pick_arg(struct starpu_codelet_pack_arg_data *state, void **ptr, size_t *size);
 
+/**
+   Finish unpacking data, after calling starpu_codelet_unpack_arg_init()
+   once and starpu_codelet_unpack_arg() or starpu_codelet_dup_arg() or
+   starpu_codelet_pick_arg() several times.
+*/
 void starpu_codelet_unpack_arg_fini(struct starpu_codelet_pack_arg_data *state);
 
 /**
@@ -562,7 +572,6 @@ void starpu_codelet_unpack_arg_fini(struct starpu_codelet_pack_arg_data *state);
 */
 void starpu_codelet_unpack_discard_arg(struct starpu_codelet_pack_arg_data *state);
 
-
 /**
    Similar to starpu_codelet_unpack_args(), but if any parameter is 0,
    copy the part of \p cl_arg that has not been read in \p buffer

src/util/starpu_task_insert_utils.c

@@ -63,10 +63,10 @@ void starpu_codelet_pack_arg_fini(struct starpu_codelet_pack_arg_data *state, vo
 	*cl_arg_size = state->arg_buffer_size;
 }
 
-void starpu_codelet_unpack_arg_init(struct starpu_codelet_pack_arg_data *state, void **cl_arg, size_t *cl_arg_size)
+void starpu_codelet_unpack_arg_init(struct starpu_codelet_pack_arg_data *state, void *cl_arg, size_t cl_arg_size)
 {
-	state->arg_buffer = *cl_arg;
-	state->arg_buffer_size = *cl_arg_size;
+	state->arg_buffer = cl_arg;
+	state->arg_buffer_size = cl_arg_size;
 	state->current_offset = sizeof(int);
 	state->nargs = 0;
 }
@@ -75,11 +75,11 @@ void starpu_codelet_unpack_arg(struct starpu_codelet_pack_arg_data *state, void
 {
 	size_t ptr_size;
 	memcpy((void *)&ptr_size, state->arg_buffer+state->current_offset, sizeof(ptr_size));
-	assert(ptr_size==size);
-	state->current_offset += sizeof(ptr_size);
+	STARPU_ASSERT_MSG(ptr_size==size, "The given size (%ld) is not the size of the next argument (%ld)\n", size, ptr_size);
+	state->current_offset += sizeof(size);
 
 	memcpy(ptr, state->arg_buffer+state->current_offset, ptr_size);
-	state->current_offset += ptr_size;
+	state->current_offset += size;
 
 	state->nargs++;
 }
@@ -107,9 +107,12 @@ void starpu_codelet_pick_arg(struct starpu_codelet_pack_arg_data *state, void **
 	state->nargs++;
 }
 
-void starpu_codelet_unpack_arg_fini(struct starpu_codelet_pack_arg_data *state STARPU_ATTRIBUTE_UNUSED)
+void starpu_codelet_unpack_arg_fini(struct starpu_codelet_pack_arg_data *state)
 {
-
+	if (state->current_offset < state->arg_buffer_size)
+	{
+		_STARPU_MSG("Arguments still need to be unpacked from the starpu_codelet_pack_arg_data (offset %ld - buffer_size %ld)\n", state->current_offset, state->arg_buffer_size);
+	}
 }
 
 void starpu_codelet_unpack_discard_arg(struct starpu_codelet_pack_arg_data *state)

starpupy/src/starpu_task_wrapper.c

@@ -82,7 +82,7 @@ void prologue_cb_func(void *cl_arg)
 	struct starpu_task *task = starpu_task_get_current();
 	/*Initialize struct starpu_codelet_unpack_arg_data*/
 	struct starpu_codelet_pack_arg_data data_org;
-	starpu_codelet_unpack_arg_init(&data_org, &task->cl_arg, &task->cl_arg_size);
+	starpu_codelet_unpack_arg_init(&data_org, task->cl_arg, task->cl_arg_size);
 
 	/*get func_py char**/
 	starpu_codelet_pick_arg(&data_org, (void**)&func_data, &func_data_size);
@@ -124,7 +124,7 @@ void prologue_cb_func(void *cl_arg)
 				/*call obj = asyncio.run_coroutine_threadsafe(wait_for_fut(obj), loop)*/
 				obj = PyObject_CallMethod(asyncio_module, "run_coroutine_threadsafe", "O,O", wait_obj, loop);
 			}
-		    
+
 			/*if one of arguments is Future, get its result*/
 			PyObject *fut_result = PyObject_CallMethod(obj, "result", NULL);
 			/*replace the Future argument to its result*/
@@ -169,7 +169,7 @@ void starpupy_codelet_func(void *buffers[], void *cl_arg)
 	struct starpu_task *task = starpu_task_get_current();
 	/*Initialize struct starpu_codelet_unpack_arg_data*/
 	struct starpu_codelet_pack_arg_data data;
-	starpu_codelet_unpack_arg_init(&data, &task->cl_arg, &task->cl_arg_size);
+	starpu_codelet_unpack_arg_init(&data, task->cl_arg, task->cl_arg_size);
 
 	/*get func_py char**/
 	starpu_codelet_pick_arg(&data, (void**)&func_data, &func_data_size);
@@ -225,7 +225,7 @@ void starpupy_codelet_func(void *buffers[], void *cl_arg)
 		char* rv_data=NULL;
 		Py_ssize_t rv_data_size=0;
 		starpu_codelet_pack_arg(&data_ret, &rv_data_size, sizeof(rv_data_size));
-	    starpu_codelet_pack_arg(&data_ret, &rv_data, sizeof(rv_data));
+		starpu_codelet_pack_arg(&data_ret, &rv_data, sizeof(rv_data));
 	}
 	/*else use cloudpickle to dump rv*/
 	else
@@ -264,7 +264,7 @@ void epilogue_cb_func(void *v)
 
 	/*Initialize struct starpu_codelet_unpack_arg_data data*/
 	struct starpu_codelet_pack_arg_data data;
-	starpu_codelet_unpack_arg_init(&data, &task->cl_arg, &task->cl_arg_size);
+	starpu_codelet_unpack_arg_init(&data, task->cl_arg, task->cl_arg_size);
 
 	/*skip func_py*/
 	starpu_codelet_unpack_discard_arg(&data);
@@ -279,7 +279,7 @@ void epilogue_cb_func(void *v)
 
 	/*Initialize struct starpu_codelet_unpack_arg_data data*/
 	struct starpu_codelet_pack_arg_data data_ret;
-	starpu_codelet_unpack_arg_init(&data_ret, &task->cl_ret, &task->cl_ret_size);
+	starpu_codelet_unpack_arg_init(&data_ret, task->cl_ret, task->cl_ret_size);
 	/*get rv_data_size*/
 	starpu_codelet_unpack_arg(&data_ret, &rv_data_size, sizeof(rv_data_size));
 
@@ -354,7 +354,7 @@ static size_t sizebase (struct starpu_task *task, unsigned nimpl)
 
 	/*Initialize struct starpu_codelet_unpack_arg_data*/
 	struct starpu_codelet_pack_arg_data data;
-	starpu_codelet_unpack_arg_init(&data, &task->cl_arg, &task->cl_arg_size);
+	starpu_codelet_unpack_arg_init(&data, task->cl_arg, task->cl_arg_size);
 
 	/*skip func_py*/
 	//starpu_codelet_unpack_discard_arg(&data);
@@ -518,9 +518,9 @@ static PyObject* starpu_task_submit_wrapper(PyObject *self, PyObject *args)
 	Py_ssize_t func_data_size;
 	PyObject *func_bytes;
 	char* func_data = starpu_cloudpickle_dumps(func_py, &func_bytes, &func_data_size);
-    starpu_codelet_pack_arg(&data, func_data, func_data_size);
-    Py_DECREF(func_bytes);
-    /*pack argList*/
+	starpu_codelet_pack_arg(&data, func_data, func_data_size);
+	Py_DECREF(func_bytes);
+	/*pack argList*/
 	starpu_codelet_pack_arg(&data, &argList, sizeof(argList));
 	/*pack fut*/
 	starpu_codelet_pack_arg(&data, &fut, sizeof(fut));
@@ -789,7 +789,7 @@ PyInit_starpupy(void)
 	/*numpy import array*/
 	import_array();
 #endif
-	
+
 	return m;
 }
 /***********************************************************************************/

tests/main/pack.c

@@ -21,7 +21,7 @@
  * Test starpu_codelet_pack_args and starpu_codelet_unpack_args
  */
 
-void func_cpu(void *descr[], void *_args)
+void func_unpack_args(void *descr[], void *_args)
 {
 	int factor;
 	char c;
@@ -31,14 +31,103 @@ void func_cpu(void *descr[], void *_args)
 
 	starpu_codelet_unpack_args(_args, &factor, &c, &x);
 
-        FPRINTF(stderr, "[codelet] values: %d %c %d\n", factor, c, x);
+        FPRINTF(stderr, "[codelet unpack_args] values: %d %c %d\n", factor, c, x);
 	assert(factor == 12 && c == 'n' && x == 42);
 }
 
-struct starpu_codelet mycodelet =
+struct starpu_codelet mycodelet_unpack_args =
 {
-	.cpu_funcs = {func_cpu},
-	.cpu_funcs_name = {"func_cpu"},
+	.cpu_funcs = {func_unpack_args},
+	.cpu_funcs_name = {"func_unpack_args"},
+        .nbuffers = 0
+};
+
+void func_unpack_arg(void *descr[], void *_args)
+{
+	int factor;
+	char c;
+	int x;
+
+	(void)descr;
+
+	size_t size = sizeof(int) + 3*sizeof(size_t) + sizeof(int) + sizeof(char) + sizeof(int);
+	struct starpu_codelet_pack_arg_data state;
+	starpu_codelet_unpack_arg_init(&state, _args, size);
+	starpu_codelet_unpack_arg(&state, (void**)&factor, sizeof(factor));
+	starpu_codelet_unpack_arg(&state, (void**)&c, sizeof(c));
+	starpu_codelet_unpack_arg(&state, (void**)&x, sizeof(x));
+	starpu_codelet_unpack_arg_fini(&state);
+
+        FPRINTF(stderr, "[codelet unpack_arg] values: %d %c %d\n", factor, c, x);
+	assert(factor == 12 && c == 'n' && x == 42);
+}
+
+struct starpu_codelet mycodelet_unpack_arg =
+{
+	.cpu_funcs = {func_unpack_arg},
+	.cpu_funcs_name = {"func_unpack_arg"},
+        .nbuffers = 0
+};
+
+void func_dup_arg(void *descr[], void *_args)
+{
+	int *factor;
+	char *c;
+	int *x;
+	size_t size;
+
+	(void)descr;
+
+	size_t psize = sizeof(int) + 3*sizeof(size_t) + sizeof(int) + sizeof(char) + sizeof(int);
+	struct starpu_codelet_pack_arg_data state;
+	starpu_codelet_unpack_arg_init(&state, _args, psize);
+	starpu_codelet_dup_arg(&state, (void**)&factor, &size);
+	assert(size == sizeof(*factor));
+	starpu_codelet_dup_arg(&state, (void**)&c, &size);
+	assert(size == sizeof(*c));
+	starpu_codelet_dup_arg(&state, (void**)&x, &size);
+	assert(size == sizeof(*x));
+	starpu_codelet_unpack_arg_fini(&state);
+
+        FPRINTF(stderr, "[codelet dup_arg] values: %d %c %d\n", *factor, *c, *x);
+	assert(*factor == 12 && *c == 'n' && *x == 42);
+}
+
+struct starpu_codelet mycodelet_dup_arg =
+{
+	.cpu_funcs = {func_dup_arg},
+	.cpu_funcs_name = {"func_dup_arg"},
+        .nbuffers = 0
+};
+
+void func_pick_arg(void *descr[], void *_args)
+{
+	int *factor;
+	char *c;
+	int *x;
+	size_t size;
+
+	(void)descr;
+
+	size_t psize = sizeof(int) + 3*sizeof(size_t) + sizeof(int) + sizeof(char) + sizeof(int);
+	struct starpu_codelet_pack_arg_data state;
+	starpu_codelet_unpack_arg_init(&state, _args, psize);
+	starpu_codelet_pick_arg(&state, (void**)&factor, &size);
+	assert(size == sizeof(*factor));
+	starpu_codelet_pick_arg(&state, (void**)&c, &size);
+	assert(size == sizeof(*c));
+	starpu_codelet_pick_arg(&state, (void**)&x, &size);
+	assert(size == sizeof(*x));
+	starpu_codelet_unpack_arg_fini(&state);
+
+        FPRINTF(stderr, "[codelet pick_arg] values: %d %c %d\n", *factor, *c, *x);
+	assert(*factor == 12 && *c == 'n' && *x == 42);
+}
+
+struct starpu_codelet mycodelet_pick_arg =
+{
+	.cpu_funcs = {func_pick_arg},
+	.cpu_funcs_name = {"func_pick_arg"},
         .nbuffers = 0
 };
 
@@ -48,7 +137,6 @@ int main(void)
         int x=42;
 	int factor=12;
 	char c='n';
-	struct starpu_task *task, *task2;
 
 	ret = starpu_init(NULL);
 	if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
@@ -56,36 +144,87 @@ int main(void)
 
         FPRINTF(stderr, "[init] values: %d %c %d\n", factor, c, x);
 
-	task = starpu_task_create();
-	task->synchronous = 1;
-	task->cl = &mycodelet;
-	task->cl_arg_free = 1;
-	starpu_codelet_pack_args(&task->cl_arg, &task->cl_arg_size,
-				 STARPU_VALUE, &factor, sizeof(factor),
-				 STARPU_VALUE, &c, sizeof(c),
-				 STARPU_VALUE, &x, sizeof(x),
-				 0);
-	ret = starpu_task_submit(task);
-	if (ret != -ENODEV)
-		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
-
-	task2 = starpu_task_create();
-	task2->synchronous = 1;
-	task2->cl = &mycodelet;
-	task2->cl_arg_free = 1;
-
 	{
+		struct starpu_task *task = starpu_task_build(&mycodelet_unpack_args, STARPU_TASK_SYNCHRONOUS, 1, 0);
+		task->cl_arg_free = 1;
+
+		starpu_codelet_pack_args(&task->cl_arg, &task->cl_arg_size,
+					 STARPU_VALUE, &factor, sizeof(factor),
+					 STARPU_VALUE, &c, sizeof(c),
+					 STARPU_VALUE, &x, sizeof(x),
+					 0);
+		ret = starpu_task_submit(task);
+		if (ret != -ENODEV)
+			STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
+	}
+
+	/* Test with starpu_codelet_unpack_args */
+ 	{
+		struct starpu_task *task = starpu_task_build(&mycodelet_unpack_args, STARPU_TASK_SYNCHRONOUS, 1, 0);
+		task->cl_arg_free = 1;
+
+		struct starpu_codelet_pack_arg_data state;
+		starpu_codelet_pack_arg_init(&state);
+		starpu_codelet_pack_arg(&state, &factor, sizeof(factor));
+		starpu_codelet_pack_arg(&state, &c, sizeof(c));
+		starpu_codelet_pack_arg(&state, &x, sizeof(x));
+		starpu_codelet_pack_arg_fini(&state, &task->cl_arg, &task->cl_arg_size);
+
+		ret = starpu_task_submit(task);
+		if (ret != -ENODEV)
+			STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
+	}
+
+	/* Test with starpu_codelet_unpack_arg */
+ 	{
+		struct starpu_task *task = starpu_task_build(&mycodelet_unpack_arg, STARPU_TASK_SYNCHRONOUS, 1, 0);
+		task->cl_arg_free = 1;
+
+		struct starpu_codelet_pack_arg_data state;
+		starpu_codelet_pack_arg_init(&state);
+		starpu_codelet_pack_arg(&state, &factor, sizeof(factor));
+		starpu_codelet_pack_arg(&state, &c, sizeof(c));
+		starpu_codelet_pack_arg(&state, &x, sizeof(x));
+		starpu_codelet_pack_arg_fini(&state, &task->cl_arg, &task->cl_arg_size);
+
+		ret = starpu_task_submit(task);
+		if (ret != -ENODEV)
+			STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
+	}
+
+	/* Test with starpu_codelet_dup_arg */
+ 	{
+		struct starpu_task *task = starpu_task_build(&mycodelet_dup_arg, STARPU_TASK_SYNCHRONOUS, 1, 0);
+		task->cl_arg_free = 1;
+
 		struct starpu_codelet_pack_arg_data state;
 		starpu_codelet_pack_arg_init(&state);
 		starpu_codelet_pack_arg(&state, &factor, sizeof(factor));
 		starpu_codelet_pack_arg(&state, &c, sizeof(c));
 		starpu_codelet_pack_arg(&state, &x, sizeof(x));
-		starpu_codelet_pack_arg_fini(&state, &task2->cl_arg, &task2->cl_arg_size);
+		starpu_codelet_pack_arg_fini(&state, &task->cl_arg, &task->cl_arg_size);
+
+		ret = starpu_task_submit(task);
+		if (ret != -ENODEV)
+			STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
 	}
 
-	ret = starpu_task_submit(task2);
-	if (ret != -ENODEV)
-		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
+	/* Test with starpu_codelet_pick_arg */
+ 	{
+		struct starpu_task *task = starpu_task_build(&mycodelet_pick_arg, STARPU_TASK_SYNCHRONOUS, 1, 0);
+		task->cl_arg_free = 1;
+
+		struct starpu_codelet_pack_arg_data state;
+		starpu_codelet_pack_arg_init(&state);
+		starpu_codelet_pack_arg(&state, &factor, sizeof(factor));
+		starpu_codelet_pack_arg(&state, &c, sizeof(c));
+		starpu_codelet_pack_arg(&state, &x, sizeof(x));
+		starpu_codelet_pack_arg_fini(&state, &task->cl_arg, &task->cl_arg_size);
+
+		ret = starpu_task_submit(task);
+		if (ret != -ENODEV)
+			STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
+	}
 
 	starpu_shutdown();
 	if (ret == -ENODEV)