Rework a bit and make public starpu_task_insert_data_make_room, starpu_task_insert_data_process_arg, starpu_task_insert_data_process_array_arg, starpu_task_insert_data_process_mode_array_arg

ChangeLog

@@ -93,6 +93,10 @@ Small features:
      specific ICC examples
    * Add starpu_codelet_pack_arg_init, starpu_codelet_pack_arg,
      starpu_codelet_pack_arg_fini for more fine-grain packing capabilities.
+   * Add starpu_task_insert_data_make_room,
+   starpu_task_insert_data_process_arg,
+   starpu_task_insert_data_process_array_arg,
+   starpu_task_insert_data_process_mode_array_arg
 
 StarPU 1.2.3 (svn revision 22444)
 ==============================================

doc/doxygen/chapters/api/insert_task.doxy

@@ -156,6 +156,33 @@ be followed by a number of tasks, and an array containing these tasks.
 The function starpu_task_declare_deps_array() will be called with the
 given values.
 
+\fn void starpu_task_insert_data_make_room(struct starpu_codelet *cl, struct starpu_task *task, int *allocated_buffers, int current_buffer, int room)
+\ingroup API_Insert_Task
+Assuming that there are already \p current_buffer data handles passed to
+the task, and if *allocated_buffers is not 0, the <c>task->dyn_handles</c>
+array has size \p *allocated_buffers, this function makes room for \p room
+other data handles, allocating or reallocating <c>task->dyn_handles</c> as
+necessary and updating \p *allocated_buffers accordingly. One can thus start
+with *allocated_buffers equal to 0 and current_buffer equal to 0, then make room
+by calling this function, then store handles with STARPU_TASK_SET_HANDLE(), make
+room again with this function, store yet more handles, etc.
+
+\fn void starpu_task_insert_data_process_arg(struct starpu_codelet *cl, struct starpu_task *task, int *allocated_buffers, int *current_buffer, int arg_type, starpu_data_handle_t handle)
+\ingroup API_Insert_Task
+This stores data handle \p handle into task \p task with mode \p arg_type,
+updating \p *allocated_buffers and \p *current_buffer accordingly.
+
+\fn void starpu_task_insert_data_process_array_arg(struct starpu_codelet *cl, struct starpu_task *task, int *allocated_buffers, int *current_buffer, int nb_handles, starpu_data_handle_t *handles)
+\ingroup API_Insert_Task
+This stores \p nb_handles data handles \p handles into task \p task, updating \p
+*allocated_buffers and \p *current_buffer accordingly.
+
+
+\fn void starpu_task_insert_data_process_mode_array_arg(struct starpu_codelet *cl, struct starpu_task *task, int *allocated_buffers, int *current_buffer, int nb_descrs, struct starpu_data_descr *descrs);
+\ingroup API_Insert_Task
+This stores \p nb_descrs data handles described by \p descrs into task \p task,
+updating \p *allocated_buffers and \p *current_buffer accordingly.
+
 \fn void starpu_codelet_pack_args(void **arg_buffer, size_t *arg_buffer_size, ...)
 \ingroup API_Insert_Task
 Pack arguments of type ::STARPU_VALUE into a buffer which can be

include/starpu_task_util.h

@@ -70,6 +70,11 @@ int starpu_task_insert(struct starpu_codelet *cl, ...);
 /* the function starpu_insert_task has the same semantics as starpu_task_insert, it is kept to avoid breaking old codes */
 int starpu_insert_task(struct starpu_codelet *cl, ...);
 
+void starpu_task_insert_data_make_room(struct starpu_codelet *cl, struct starpu_task *task, int *allocated_buffers, int current_buffer, int room);
+void starpu_task_insert_data_process_arg(struct starpu_codelet *cl, struct starpu_task *task, int *allocated_buffers, int *current_buffer, int arg_type, starpu_data_handle_t handle);
+void starpu_task_insert_data_process_array_arg(struct starpu_codelet *cl, struct starpu_task *task, int *allocated_buffers, int *current_buffer, int nb_handles, starpu_data_handle_t *handles);
+void starpu_task_insert_data_process_mode_array_arg(struct starpu_codelet *cl, struct starpu_task *task, int *allocated_buffers, int *current_buffer, int nb_descrs, struct starpu_data_descr *descrs);
+
 void starpu_codelet_pack_args(void **arg_buffer, size_t *arg_buffer_size, ...);
 
 struct starpu_codelet_pack_arg {

src/util/starpu_task_insert_utils.c

@@ -202,8 +202,7 @@ int _starpu_codelet_pack_args(void **arg_buffer, size_t *arg_buffer_size, va_lis
 	return 0;
 }
 
-static
-void _starpu_task_insert_data_make_room(struct starpu_codelet *cl, struct starpu_task *task, int *allocated_buffers, int current_buffer, int room)
+void starpu_task_insert_data_make_room(struct starpu_codelet *cl, struct starpu_task *task, int *allocated_buffers, int current_buffer, int room)
 {
 	if (current_buffer + room > STARPU_NMAXBUFS)
 	{
@@ -238,13 +237,13 @@ void _starpu_task_insert_data_make_room(struct starpu_codelet *cl, struct starpu
 	}
 }
 
-static inline void starpu_task_insert_process_data_arg(struct starpu_codelet *cl, struct starpu_task *task, int arg_type, starpu_data_handle_t handle, int *current_buffer, int *allocated_buffers)
+void starpu_task_insert_data_process_arg(struct starpu_codelet *cl, struct starpu_task *task, int *allocated_buffers, int *current_buffer, int arg_type, starpu_data_handle_t handle)
 {
 	enum starpu_data_access_mode mode = (enum starpu_data_access_mode) arg_type & ~STARPU_SSEND;
 	STARPU_ASSERT(cl != NULL);
 	STARPU_ASSERT_MSG(cl->nbuffers == STARPU_VARIABLE_NBUFFERS || *current_buffer < cl->nbuffers, "Too many data passed to starpu_task_insert");
 
-	_starpu_task_insert_data_make_room(cl, task, allocated_buffers, *current_buffer, 1);
+	starpu_task_insert_data_make_room(cl, task, allocated_buffers, *current_buffer, 1);
 
 	STARPU_TASK_SET_HANDLE(task, handle, *current_buffer);
 	if (cl->nbuffers == STARPU_VARIABLE_NBUFFERS || (cl->nbuffers > STARPU_NMAXBUFS && !cl->dyn_modes))
@@ -268,11 +267,11 @@ static inline void starpu_task_insert_process_data_arg(struct starpu_codelet *cl
 	(*current_buffer)++;
 }
 
-static inline void starpu_task_insert_process_data_array_arg(struct starpu_codelet *cl, struct starpu_task *task, int nb_handles, starpu_data_handle_t *handles, int *current_buffer, int *allocated_buffers)
+void starpu_task_insert_data_process_array_arg(struct starpu_codelet *cl, struct starpu_task *task, int *allocated_buffers, int *current_buffer, int nb_handles, starpu_data_handle_t *handles)
 {
 	STARPU_ASSERT(cl != NULL);
 
-	_starpu_task_insert_data_make_room(cl, task, allocated_buffers, *current_buffer, nb_handles);
+	starpu_task_insert_data_make_room(cl, task, allocated_buffers, *current_buffer, nb_handles);
 
 	int i;
 	for(i=0 ; i<nb_handles ; i++)
@@ -282,11 +281,11 @@ static inline void starpu_task_insert_process_data_array_arg(struct starpu_codel
 	}
 }
 
-static inline void starpu_task_insert_process_data_mode_array_arg(struct starpu_codelet *cl, struct starpu_task *task, int nb_descrs, struct starpu_data_descr *descrs, int *current_buffer, int *allocated_buffers)
+void starpu_task_insert_data_process_mode_array_arg(struct starpu_codelet *cl, struct starpu_task *task, int *allocated_buffers, int *current_buffer, int nb_descrs, struct starpu_data_descr *descrs)
 {
 	STARPU_ASSERT(cl != NULL);
 
-	_starpu_task_insert_data_make_room(cl, task, allocated_buffers, *current_buffer, nb_descrs);
+	starpu_task_insert_data_make_room(cl, task, allocated_buffers, *current_buffer, nb_descrs);
 
 	int i;
 	for(i=0 ; i<nb_descrs ; i++)
@@ -338,21 +337,21 @@ int _starpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task *ta
 		{
 			/* We have an access mode : we expect to find a handle */
 			starpu_data_handle_t handle = va_arg(varg_list, starpu_data_handle_t);
-			starpu_task_insert_process_data_arg(cl, task, arg_type, handle, &current_buffer, &allocated_buffers);
+			starpu_task_insert_data_process_arg(cl, task, &allocated_buffers, &current_buffer, arg_type, handle);
 		}
 		else if (arg_type == STARPU_DATA_ARRAY)
 		{
 			// Expect to find a array of handles and its size
 			starpu_data_handle_t *handles = va_arg(varg_list, starpu_data_handle_t *);
 			int nb_handles = va_arg(varg_list, int);
-			starpu_task_insert_process_data_array_arg(cl, task, nb_handles, handles, &current_buffer, &allocated_buffers);
+			starpu_task_insert_data_process_array_arg(cl, task, &allocated_buffers, &current_buffer, nb_handles, handles);
 		}
 		else if (arg_type==STARPU_DATA_MODE_ARRAY)
 		{
 			// Expect to find a array of descr and its size
 			struct starpu_data_descr *descrs = va_arg(varg_list, struct starpu_data_descr *);
 			int nb_descrs = va_arg(varg_list, int);
-			starpu_task_insert_process_data_mode_array_arg(cl, task, nb_descrs, descrs, &current_buffer, &allocated_buffers);
+			starpu_task_insert_data_process_mode_array_arg(cl, task, &allocated_buffers, &current_buffer, nb_descrs, descrs);
 		}
 		else if (arg_type==STARPU_VALUE)
 		{
@@ -545,7 +544,7 @@ int _fstarpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task *t
 		{
 			arg_i++;
 			starpu_data_handle_t handle = arglist[arg_i];
-			starpu_task_insert_process_data_arg(cl, task, arg_type, handle, &current_buffer, &allocated_buffers);
+			starpu_task_insert_data_process_arg(cl, task, &allocated_buffers, &current_buffer, arg_type, handle);
 		}
 		else if (arg_type == STARPU_DATA_ARRAY)
 		{
@@ -553,7 +552,7 @@ int _fstarpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task *t
 			starpu_data_handle_t *handles = arglist[arg_i];
 			arg_i++;
 			int nb_handles = *(int *)arglist[arg_i];
-			starpu_task_insert_process_data_array_arg(cl, task, nb_handles, handles, &current_buffer, &allocated_buffers);
+			starpu_task_insert_data_process_array_arg(cl, task, &allocated_buffers, &current_buffer, nb_handles, handles);
 		}
 		else if (arg_type == STARPU_DATA_MODE_ARRAY)
 		{
@@ -561,7 +560,7 @@ int _fstarpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task *t
 			struct starpu_data_descr *descrs = arglist[arg_i];
 			arg_i++;
 			int nb_descrs = *(int *)arglist[arg_i];
-			starpu_task_insert_process_data_mode_array_arg(cl, task, nb_descrs, descrs, &current_buffer, &allocated_buffers);
+			starpu_task_insert_data_process_mode_array_arg(cl, task, &allocated_buffers, &current_buffer, nb_descrs, descrs);
 		}
 		else if (arg_type == STARPU_VALUE)
 		{