Add a new value STARPU_TASK_SYNCHRONOUS to be used in starpu_task_insert() to define if the task is (or not) synchronous

ChangeLog

@@ -74,7 +74,7 @@ Small features:
   * Add SubmitOrder trace field.
   * Add workerids and workerids_len task fields.
   * Add priority management to StarPU-MPI. Can be disabled with
-  the STARPU_MPI_PRIORITIES environment variable.
+    the STARPU_MPI_PRIORITIES environment variable.
   * Add STARPU_MAIN_THREAD_CPUID and STARPU_MPI_THREAD_CPUID environment
     variables.
   * Add disk to disk copy functions and support asynchronous full read/write
@@ -96,6 +96,8 @@ Small features:
   * New functions
     starpu_data_partition_submit_sequential_consistency() and
     starpu_data_unpartition_submit_sequential_consistency()
+  * Add a new value STARPU_TASK_SYNCHRONOUS to be used in
+    starpu_task_insert() to define if the task is (or not) synchronous
 
 Changes:
   * Vastly improve simgrid simulation time.

doc/doxygen/chapters/api/insert_task.doxy

@@ -42,7 +42,7 @@ 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, ::STARPU_CL_ARGS, ::STARPU_CL_ARGS_NFREE,
-::STARPU_TASK_DEPS_ARRAY, ::STARPU_TASK_COLOR, ::STARPU_HANDLES_SEQUENTIAL_CONSISTENCY
+::STARPU_TASK_DEPS_ARRAY, ::STARPU_TASK_COLOR, ::STARPU_HANDLES_SEQUENTIAL_CONSISTENCY, ::STARPU_TASK_SYNCHRONOUS
 followed by the appropriated objects as defined elsewhere.
 </ul>
 
@@ -161,6 +161,11 @@ given values.
 Used when calling starpu_task_insert(), must be followed by an integer
 representing a color
 
+\def STARPU_TASK_SYNCHRONOUS
+\ingroup API_Insert_Task
+Used when calling starpu_task_insert(), must be followed by an integer
+stating if the task is synchronous or not
+
 \def STARPU_HANDLES_SEQUENTIAL_CONSISTENCY
 \ingroup API_Insert_Task
 Used when calling starpu_task_insert(), must be followed by an array

include/fstarpu_mod.f90

@@ -56,6 +56,7 @@ module fstarpu_mod
         type(c_ptr), bind(C) :: FSTARPU_TAG_ONLY
         type(c_ptr), bind(C) :: FSTARPU_NAME
         type(c_ptr), bind(C) :: FSTARPU_TASK_COLOR
+        type(c_ptr), bind(C) :: FSTARPU_TASK_SYNCHRONOUS
         type(c_ptr), bind(C) :: FSTARPU_HANDLES_SEQUENTIAL_CONSISTENCY
         type(c_ptr), bind(C) :: FSTARPU_NODE_SELECTION_POLICY
 

include/starpu_task_util.h

@@ -65,7 +65,8 @@ void starpu_create_sync_task(starpu_tag_t sync_tag, unsigned ndeps, starpu_tag_t
 #define STARPU_TASK_DEPS_ARRAY	(27<<STARPU_MODE_SHIFT)
 #define STARPU_TASK_COLOR       (28<<STARPU_MODE_SHIFT)
 #define STARPU_HANDLES_SEQUENTIAL_CONSISTENCY (29<<STARPU_MODE_SHIFT)
-#define STARPU_SHIFTED_MODE_MAX (30<<STARPU_MODE_SHIFT)
+#define STARPU_TASK_SYNCHRONOUS (30<<STARPU_MODE_SHIFT)
+#define STARPU_SHIFTED_MODE_MAX (31<<STARPU_MODE_SHIFT)
 
 int starpu_task_set(struct starpu_task *task, struct starpu_codelet *cl, ...);
 struct starpu_task *starpu_task_build(struct starpu_codelet *cl, ...);

mpi/src/starpu_mpi_task_insert.c

@@ -452,6 +452,10 @@ int _starpu_mpi_task_decode_v(struct starpu_codelet *codelet, int me, int nb_nod
                 {
                         (void)va_arg(varg_list_copy, int);
                 }
+		else if (arg_type==STARPU_TASK_SYNCHRONOUS)
+                {
+                        (void)va_arg(varg_list_copy, int);
+                }
 		else if (arg_type==STARPU_HANDLES_SEQUENTIAL_CONSISTENCY)
                 {
                         (void)va_arg(varg_list_copy, char *);

mpi/src/starpu_mpi_task_insert_fortran.c

@@ -298,6 +298,11 @@ int _fstarpu_mpi_task_decode_v(struct starpu_codelet *codelet, int me, int nb_no
 			arg_i++;
 			/* int* */
 		}
+		else if (arg_type==STARPU_TASK_SYNCHRONOUS)
+		{
+			arg_i++;
+			/* int* */
+		}
 		else if (arg_type==STARPU_HANDLES_SEQUENTIAL_CONSISTENCY)
 		{
 			arg_i++;

src/util/fstarpu.c

@@ -59,6 +59,7 @@ static const intptr_t fstarpu_tag_only	= STARPU_TAG_ONLY;
 static const intptr_t fstarpu_name	= STARPU_NAME;
 static const intptr_t fstarpu_task_color	= STARPU_TASK_COLOR;
 static const intptr_t fstarpu_handles_sequential_consistency	= STARPU_HANDLES_SEQUENTIAL_CONSISTENCY;
+static const intptr_t fstarpu_task_synchronous	= STARPU_TASK_SYNCHRONOUS;
 static const intptr_t fstarpu_node_selection_policy	= STARPU_NODE_SELECTION_POLICY;
 
 static const intptr_t fstarpu_value = STARPU_VALUE;
@@ -137,6 +138,7 @@ intptr_t fstarpu_get_constant(char *s)
 	else if (!strcmp(s, "FSTARPU_SCHED_CTX"))	{ return fstarpu_sched_ctx; }
 	else if (!strcmp(s, "FSTARPU_TASK_COLOR"))	{ return fstarpu_task_color; }
 	else if (!strcmp(s, "FSTARPU_HANDLES_SEQUENTIAL_CONSISTENCY"))	{ return fstarpu_handles_sequential_consistency; }
+	else if (!strcmp(s, "FSTARPU_TASK_SYNCHRONOUS"))	{ return fstarpu_task_synchronous; }
 
 	else if (!strcmp(s, "FSTARPU_CPU_WORKER"))	{ return fstarpu_cpu_worker; }
 	else if (!strcmp(s, "FSTARPU_CUDA_WORKER"))	{ return fstarpu_cuda_worker; }

src/util/starpu_task_insert_utils.c

@@ -196,6 +196,10 @@ int _starpu_codelet_pack_args(void **arg_buffer, size_t *arg_buffer_size, va_lis
                 {
                         (void)va_arg(varg_list, int);
                 }
+		else if (arg_type==STARPU_TASK_SYNCHRONOUS)
+                {
+                        (void)va_arg(varg_list, int);
+                }
 		else if (arg_type==STARPU_HANDLES_SEQUENTIAL_CONSISTENCY)
                 {
                         (void)va_arg(varg_list, char *);
@@ -494,6 +498,10 @@ int _starpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task *ta
                 {
                         task->color = va_arg(varg_list, int);
                 }
+		else if (arg_type==STARPU_TASK_SYNCHRONOUS)
+                {
+                        task->synchronous = va_arg(varg_list, int);
+                }
 		else if (arg_type==STARPU_HANDLES_SEQUENTIAL_CONSISTENCY)
                 {
                         task->handles_sequential_consistency = va_arg(varg_list, char *);
@@ -737,6 +745,11 @@ int _fstarpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task *t
                         arg_i++;
                         task->color = *(int *)arglist[arg_i];
                 }
+		else if (arg_type == STARPU_TASK_SYNCHRONOUS)
+                {
+                        arg_i++;
+                        task->synchronous = *(int *)arglist[arg_i];
+                }
 		else if (arg_type==STARPU_HANDLES_SEQUENTIAL_CONSISTENCY)
                 {
                         task->handles_sequential_consistency = (char *)arglist[arg_i];