New parameters STARPU_CALLBACK_ARG_NFREE, STARPU_CALLBACK_WITH_ARG_NFREE, STARPU_PROLOGUE_CALLBACK_ARG_NFREE, and STARPU_PROLOGUE_CALLBACK_POP_ARG_NFREE

- New semantic for starpu_task_insert() and alike parameters
  STARPU_CALLBACK_ARG, STARPU_PROLOGUE_CALLBACK_ARG, and
  STARPU_PROLOGUE_CALLBACK_POP_ARG which set respectively
  starpu_task::callback_arg_free,
  starpu_task::prologue_callback_arg_free and
  starpu_task::prologue_callback_pop_arg_free to 1 when used.
  (this was introduced in previous commit ^^^)

- New parameters STARPU_CALLBACK_ARG_NFREE,
  STARPU_CALLBACK_WITH_ARG_NFREE, STARPU_PROLOGUE_CALLBACK_ARG_NFREE,
  and STARPU_PROLOGUE_CALLBACK_POP_ARG_NFREE which set the
  corresponding fields of starpu_task to 0.

(cherry picked from commit 62e81c784317fc3ecbb40ca1b3323b2c2d791bd6)

ChangeLog

@@ -24,6 +24,18 @@ New features:
 StarPU 1.3.3 (git revision xxx)
 ==============================================
 
+New features:
+  * New semantic for starpu_task_insert() and alike parameters
+    STARPU_CALLBACK_ARG, STARPU_PROLOGUE_CALLBACK_ARG, and
+    STARPU_PROLOGUE_CALLBACK_POP_ARG which set respectively
+    starpu_task::callback_arg_free,
+    starpu_task::prologue_callback_arg_free and
+    starpu_task::prologue_callback_pop_arg_free to 1 when used.
+    New parameters STARPU_CALLBACK_ARG_NFREE,
+    STARPU_CALLBACK_WITH_ARG_NFREE, STARPU_PROLOGUE_CALLBACK_ARG_NFREE, and
+    STARPU_PROLOGUE_CALLBACK_POP_ARG_NFREE which set the corresponding
+    fields of starpu_task to 0.
+
 Small features:
   * New starpu_task_insert() and alike parameter STARPU_TASK_WORKERIDS
     allowing to set the fields starpu_task::workerids_len and
@@ -34,14 +46,6 @@ Small features:
   * New function starpu_create_callback_task() which creates and
     submits an empty task with the specified callback
 
-Small changes:
-  * Update starpu_task_insert() and alike to set
-    starpu_task::callback_arg_free,
-    starpu_task::prologue_callback_arg_free and
-    starpu_task::prologue_callback_pop_arg_free to 1 when
-    corresponding parameters (STARPU_CALLBACK_ARG,
-    STARPU_PROLOGUE_CALLBACK_ARG, and
-    STARPU_PROLOGUE_CALLBACK_POP_ARG) are used
 
 StarPU 1.3.2 (git revision af22a20fc00a37addf3cc6506305f89feed940b0)
 ==============================================

examples/callback/prologue.c

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2013,2014                                Inria
- * Copyright (C) 2010-2017                                CNRS
+ * Copyright (C) 2010-2017,2019                           CNRS
  * Copyright (C) 2009,2010,2013-2015                      Université de Bordeaux
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -92,9 +92,9 @@ int main(void)
 	ret = starpu_task_insert(&cl,
 				 STARPU_RW, handle,
 				 STARPU_PROLOGUE_CALLBACK, prologue_callback_func,
-				 STARPU_PROLOGUE_CALLBACK_ARG, &x,
+				 STARPU_PROLOGUE_CALLBACK_ARG_NFREE, &x,
 				 STARPU_PROLOGUE_CALLBACK_POP, pop_prologue_callback_func,
-				 STARPU_PROLOGUE_CALLBACK_POP_ARG, 5,
+				 STARPU_PROLOGUE_CALLBACK_POP_ARG_NFREE, 5,
 				 0);
 	if (ret == -ENODEV) goto enodev;
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");

examples/dependency/sequential_consistency.c

@@ -69,7 +69,7 @@ void cpu_codeletA(void *descr[], void *args)
 
 	ret = starpu_task_insert(&clB,
 				 STARPU_RW, value_handle,
-				 STARPU_CALLBACK_WITH_ARG, starpu_tag_notify_from_apps, tagHoldC,
+				 STARPU_CALLBACK_WITH_ARG_NFREE, starpu_tag_notify_from_apps, tagHoldC,
 				 STARPU_HANDLES_SEQUENTIAL_CONSISTENCY, handle_sequential_consistency,
 				 STARPU_NAME, "taskB",
 				 0);

examples/dependency/task_end_dep_add.c

@@ -47,7 +47,7 @@ void cpu_codelet(void *descr[], void *args)
 	starpu_task_end_dep_add(task, 1);
 
 	starpu_task_insert(&cl2,
-			   STARPU_CALLBACK_WITH_ARG, starpu_task_end_dep_release, task,
+			   STARPU_CALLBACK_WITH_ARG_NFREE, starpu_task_end_dep_release, task,
 			   0);
 	STARPU_ASSERT(*val == INIT);
 	*val *= 2;

examples/pipeline/pipeline.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2012-2015,2017                           CNRS
+ * Copyright (C) 2012-2015,2017,2019                      CNRS
  * Copyright (C) 2012,2014-2017                           Université de Bordeaux
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -243,7 +243,7 @@ int main(void)
 
 		ret = starpu_task_insert(&pipeline_codelet_sum,
 				STARPU_R, buffersY[l%K],
-				STARPU_CALLBACK_WITH_ARG, (void (*)(void*))sem_post, &sems[l%C],
+				STARPU_CALLBACK_WITH_ARG_NFREE, (void (*)(void*))sem_post, &sems[l%C],
 				STARPU_TAG_ONLY, (starpu_tag_t) l,
 				0);
 		if (ret == -ENODEV) goto enodev;

include/starpu_task.h

@@ -719,7 +719,9 @@ struct starpu_task
 
 	   With starpu_task_insert() and alike this can be specified thanks to
 	   ::STARPU_CALLBACK followed by the function pointer, or thanks to
-	   ::STARPU_CALLBACK_WITH_ARG followed by the function pointer and the argument.
+	   ::STARPU_CALLBACK_WITH_ARG (or
+	   ::STARPU_CALLBACK_WITH_ARG_NFREE) followed by the function
+	   pointer and the argument.
 	*/
 	void (*callback_func)(void *);
 	/**
@@ -730,7 +732,9 @@ struct starpu_task
 
 	   With starpu_task_insert() and alike this can be specified thanks to
 	   ::STARPU_CALLBACK_ARG followed by the function pointer, or thanks to
-	   ::STARPU_CALLBACK_WITH_ARG followed by the function pointer and the argument.
+	   ::STARPU_CALLBACK_WITH_ARG or
+	   ::STARPU_CALLBACK_WITH_ARG_NFREE followed by the function
+	   pointer and the argument.
 	*/
 	void *callback_arg;
 
@@ -795,8 +799,9 @@ struct starpu_task
 	   automatically call <c>free(callback_arg)</c> when
 	   destroying the task.
 
-	   With starpu_task_insert() and alike this is set to 1 when using
-	   ::STARPU_CALLBACK_ARG or ::STARPU_CALLBACK_WITH_ARG
+	   With starpu_task_insert() and alike, this is set to 1 when using
+	   ::STARPU_CALLBACK_ARG or ::STARPU_CALLBACK_WITH_ARG, or set
+	   to 0 when using ::STARPU_CALLBACK_ARG_NFREE
 	*/
 	unsigned callback_arg_free:1;
 
@@ -808,7 +813,8 @@ struct starpu_task
 	   <c>free(prologue_callback_arg)</c> when destroying the task.
 
 	   With starpu_task_insert() and alike this is set to 1 when using
-	   ::STARPU_PROLOGUE_CALLBACK_ARG.
+	   ::STARPU_PROLOGUE_CALLBACK_ARG, or set to 0 when using
+	   ::STARPU_PROLOGUE_CALLBACK_ARG_NFREE
 	*/
 	unsigned prologue_callback_arg_free:1;
 
@@ -821,7 +827,8 @@ struct starpu_task
 	   task.
 
 	   With starpu_task_insert() and alike this is set to 1 when using
-	   ::STARPU_PROLOGUE_CALLBACK_POP_ARG.
+	   ::STARPU_PROLOGUE_CALLBACK_POP_ARG, or set to 0 when using
+	   ::STARPU_PROLOGUE_CALLBACK_POP_ARG_NFREE
 	*/
 	unsigned prologue_callback_pop_arg_free:1;
 

include/starpu_task_util.h

@@ -57,7 +57,7 @@ extern "C"
    Used when calling starpu_task_insert(), must be followed by two
    pointers: one to a callback function, and the other to be given as
    an argument to the callback function; this is equivalent to using
-   both ::STARPU_CALLBACK and ::STARPU_CALLBACK_WITH_ARG.
+   both ::STARPU_CALLBACK and ::STARPU_CALLBACK_ARG.
 */
 #define STARPU_CALLBACK_WITH_ARG (3<<STARPU_MODE_SHIFT)
 
@@ -268,7 +268,42 @@ extern "C"
  */
 #define STARPU_TASK_NO_SUBMITORDER (36<<STARPU_MODE_SHIFT)
 
-#define STARPU_SHIFTED_MODE_MAX (37<<STARPU_MODE_SHIFT)
+/**
+   Used when calling starpu_task_insert(), similarly to
+   ::STARPU_CALLBACK_ARG, must be followed by a pointer to be given as
+   an argument to the callback function, the argument will not be
+   freed, i.e starpu_task::callback_arg_free will be set to 0
+*/
+#define STARPU_CALLBACK_ARG_NFREE	 (37<<STARPU_MODE_SHIFT)
+
+/**
+   Used when calling starpu_task_insert(), similarly to
+   ::STARPU_CALLBACK_WITH_ARG, must be followed by two pointers: one
+   to a callback function, and the other to be given as an argument to
+   the callback function; this is equivalent to using both
+   ::STARPU_CALLBACK and ::STARPU_CALLBACK_ARG_NFREE.
+*/
+#define STARPU_CALLBACK_WITH_ARG_NFREE	 (38<<STARPU_MODE_SHIFT)
+
+/**
+   Used when calling starpu_task_insert(), similarly to
+   ::STARPU_PROLOGUE_CALLBACK_ARG, must be followed by a
+   pointer to be given as an argument to the prologue callback
+   function, the argument will not be
+   freed, i.e starpu_task::prologue_callback_arg_free will be set to 0
+*/
+#define STARPU_PROLOGUE_CALLBACK_ARG_NFREE (39<<STARPU_MODE_SHIFT)
+
+/**
+   Used when calling starpu_task_insert(), similarly to
+   ::STARPU_PROLOGUE_CALLBACK_POP_ARG, must be followed by a pointer
+   to be given as an argument to the prologue callback pop function,
+   the argument will not be freed, i.e
+   starpu_task::prologue_callback_pop_arg_free will be set to 0
+*/
+#define STARPU_PROLOGUE_CALLBACK_POP_ARG_NFREE (40<<STARPU_MODE_SHIFT)
+
+#define STARPU_SHIFTED_MODE_MAX (41<<STARPU_MODE_SHIFT)
 
 /**
    Set the given \p task corresponding to \p cl with the following arguments.

mpi/src/starpu_mpi_task_insert.c

@@ -375,10 +375,19 @@ int _starpu_mpi_task_decode_v(struct starpu_codelet *codelet, int me, int nb_nod
 			(void)va_arg(varg_list_copy, _starpu_callback_func_t);
 			(void)va_arg(varg_list_copy, void *);
 		}
+		else if (arg_type==STARPU_CALLBACK_WITH_ARG_NFREE)
+		{
+			(void)va_arg(varg_list_copy, _starpu_callback_func_t);
+			(void)va_arg(varg_list_copy, void *);
+		}
 		else if (arg_type==STARPU_CALLBACK_ARG)
 		{
 			(void)va_arg(varg_list_copy, void *);
 		}
+		else if (arg_type==STARPU_CALLBACK_ARG_NFREE)
+		{
+			(void)va_arg(varg_list_copy, void *);
+		}
 		else if (arg_type==STARPU_PRIORITY)
 		{
 			prio = va_arg(varg_list_copy, int);
@@ -411,6 +420,10 @@ int _starpu_mpi_task_decode_v(struct starpu_codelet *codelet, int me, int nb_nod
                 {
                         (void)va_arg(varg_list_copy, void *);
                 }
+                else if (arg_type==STARPU_PROLOGUE_CALLBACK_ARG_NFREE)
+                {
+                        (void)va_arg(varg_list_copy, void *);
+                }
                 else if (arg_type==STARPU_PROLOGUE_CALLBACK_POP)
                 {
 			(void)va_arg(varg_list_copy, _starpu_callback_func_t);
@@ -419,6 +432,10 @@ int _starpu_mpi_task_decode_v(struct starpu_codelet *codelet, int me, int nb_nod
                 {
                         (void)va_arg(varg_list_copy, void *);
 		}
+                else if (arg_type==STARPU_PROLOGUE_CALLBACK_POP_ARG_NFREE)
+                {
+                        (void)va_arg(varg_list_copy, void *);
+		}
 		else if (arg_type==STARPU_EXECUTE_WHERE)
 		{
 			// the flag is decoded and set later when
@@ -844,7 +861,7 @@ void starpu_mpi_redux_data_prio(MPI_Comm comm, starpu_data_handle_t data_handle,
 				// Submit taskA
 				starpu_task_insert(&_starpu_mpi_redux_data_read_cl,
 						   STARPU_R, data_handle,
-						   STARPU_CALLBACK_WITH_ARG, _starpu_mpi_redux_data_recv_callback, args,
+						   STARPU_CALLBACK_WITH_ARG_NFREE, _starpu_mpi_redux_data_recv_callback, args,
 						   0);
 			}
 		}

mpi/src/starpu_mpi_task_insert_fortran.c

@@ -210,11 +210,23 @@ int _fstarpu_mpi_task_decode_v(struct starpu_codelet *codelet, int me, int nb_no
 			arg_i++;
 			/* void* */
 		}
+		else if (arg_type==STARPU_CALLBACK_WITH_ARG_NFREE)
+		{
+			arg_i++;
+			/* _starpu_callback_func_t */
+			arg_i++;
+			/* void* */
+		}
 		else if (arg_type==STARPU_CALLBACK_ARG)
 		{
 			arg_i++;
 			/* void* */
 		}
+		else if (arg_type==STARPU_CALLBACK_ARG_NFREE)
+		{
+			arg_i++;
+			/* void* */
+		}
 		else if (arg_type==STARPU_PRIORITY)
 		{
 			prio = *(int *)arglist[arg_i];
@@ -255,6 +267,11 @@ int _fstarpu_mpi_task_decode_v(struct starpu_codelet *codelet, int me, int nb_no
 			arg_i++;
 			/* void* */
                 }
+                else if (arg_type==STARPU_PROLOGUE_CALLBACK_ARG_NFREE)
+                {
+			arg_i++;
+			/* void* */
+                }
                 else if (arg_type==STARPU_PROLOGUE_CALLBACK_POP)
                 {
 			arg_i++;
@@ -265,6 +282,11 @@ int _fstarpu_mpi_task_decode_v(struct starpu_codelet *codelet, int me, int nb_no
 			arg_i++;
 			/* void* */
 		}
+                else if (arg_type==STARPU_PROLOGUE_CALLBACK_POP_ARG_NFREE)
+                {
+			arg_i++;
+			/* void* */
+		}
 		else if (arg_type==STARPU_EXECUTE_WHERE)
 		{
 			arg_i++;

mpi/tests/callback.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2013-2015,2017                           CNRS
+ * Copyright (C) 2013-2015,2017,2019                      CNRS
  * Copyright (C) 2014,2015,2017,2018                      Université de Bordeaux
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -71,7 +71,7 @@ int main(int argc, char **argv)
 	ret = starpu_mpi_task_insert(MPI_COMM_WORLD,
 				     NULL,
 				     STARPU_EXECUTE_ON_NODE, 0,
-				     STARPU_CALLBACK_WITH_ARG, callback, &x,
+				     STARPU_CALLBACK_WITH_ARG_NFREE, callback, &x,
 				     0);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_mpi_task_insert");
 
@@ -81,7 +81,7 @@ int main(int argc, char **argv)
 				     NULL,
 				     STARPU_EXECUTE_ON_NODE, 0,
 				     STARPU_CALLBACK, callback,
-				     STARPU_CALLBACK_ARG, &x,
+				     STARPU_CALLBACK_ARG_NFREE, &x,
 				     0);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
 
@@ -93,7 +93,7 @@ int main(int argc, char **argv)
 				     NULL,
 				     STARPU_EXECUTE_ON_NODE, 0,
 				     STARPU_PROLOGUE_CALLBACK, prologue_callback,
-				     STARPU_PROLOGUE_CALLBACK_ARG, &y,
+				     STARPU_PROLOGUE_CALLBACK_ARG_NFREE, &y,
 				     0);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
 
@@ -103,7 +103,7 @@ int main(int argc, char **argv)
 				     &my_codelet,
 				     STARPU_EXECUTE_ON_NODE, 0,
 				     STARPU_PROLOGUE_CALLBACK_POP, prologue_callback,
-				     STARPU_PROLOGUE_CALLBACK_POP_ARG, &y,
+				     STARPU_PROLOGUE_CALLBACK_POP_ARG_NFREE, &y,
 				     0);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
 

src/datawizard/filters.c

@@ -854,12 +854,12 @@ void _starpu_data_unpartition_submit(starpu_data_handle_t initial_handle, unsign
 		ret = starpu_task_insert(initial_handle->switch_cl, STARPU_W, initial_handle, STARPU_DATA_MODE_ARRAY, descr, n,
 					 STARPU_NAME, "unpartition",
 					 STARPU_HANDLES_SEQUENTIAL_CONSISTENCY, handles_sequential_consistency,
-					 STARPU_CALLBACK_WITH_ARG, callback_func, callback_arg,
+					 STARPU_CALLBACK_WITH_ARG_NFREE, callback_func, callback_arg,
 					 0);
 	else
 		ret = starpu_task_insert(initial_handle->switch_cl, STARPU_W, initial_handle, STARPU_DATA_MODE_ARRAY, descr, n,
 					 STARPU_NAME, "unpartition",
-					 STARPU_CALLBACK_WITH_ARG, callback_func, callback_arg,
+					 STARPU_CALLBACK_WITH_ARG_NFREE, callback_func, callback_arg,
 					 0);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
 

src/util/fstarpu.c

@@ -41,11 +41,15 @@ static const intptr_t fstarpu_task_deps_array	= STARPU_TASK_DEPS_ARRAY;
 static const intptr_t fstarpu_task_end_deps_array	= STARPU_TASK_END_DEPS_ARRAY;
 static const intptr_t fstarpu_callback	= STARPU_CALLBACK;
 static const intptr_t fstarpu_callback_with_arg	= STARPU_CALLBACK_WITH_ARG;
+static const intptr_t fstarpu_callback_with_arg_nfree	= STARPU_CALLBACK_WITH_ARG_NFREE;
 static const intptr_t fstarpu_callback_arg	= STARPU_CALLBACK_ARG;
+static const intptr_t fstarpu_callback_arg_nfree= STARPU_CALLBACK_ARG_NFREE;
 static const intptr_t fstarpu_prologue_callback	= STARPU_PROLOGUE_CALLBACK;
-static const intptr_t fstarpu_prologue_callback_arg	= STARPU_PROLOGUE_CALLBACK_ARG;
-static const intptr_t fstarpu_prologue_callback_pop	= STARPU_PROLOGUE_CALLBACK_POP;
-static const intptr_t fstarpu_prologue_callback_pop_arg	= STARPU_PROLOGUE_CALLBACK_POP_ARG;
+static const intptr_t fstarpu_prologue_callback_arg	  = STARPU_PROLOGUE_CALLBACK_ARG;
+static const intptr_t fstarpu_prologue_callback_arg_nfree = STARPU_PROLOGUE_CALLBACK_ARG_NFREE;
+static const intptr_t fstarpu_prologue_callback_pop	  	= STARPU_PROLOGUE_CALLBACK_POP;
+static const intptr_t fstarpu_prologue_callback_pop_arg	  	= STARPU_PROLOGUE_CALLBACK_POP_ARG;
+static const intptr_t fstarpu_prologue_callback_pop_arg_nfree	 = STARPU_PROLOGUE_CALLBACK_POP_ARG_NFREE;
 static const intptr_t fstarpu_priority	= STARPU_PRIORITY;
 static const intptr_t fstarpu_execute_on_node	= STARPU_EXECUTE_ON_NODE;
 static const intptr_t fstarpu_execute_on_data	= STARPU_EXECUTE_ON_DATA;
@@ -121,11 +125,15 @@ intptr_t fstarpu_get_constant(char *s)
 	else if	(!strcmp(s, "FSTARPU_TASK_END_DEPS_ARRAY"))	{ return fstarpu_task_end_deps_array; }
 	else if	(!strcmp(s, "FSTARPU_CALLBACK"))	{ return fstarpu_callback; }
 	else if	(!strcmp(s, "FSTARPU_CALLBACK_WITH_ARG"))	{ return fstarpu_callback_with_arg; }
-	else if	(!strcmp(s, "FSTARPU_CALLBACK_ARG"))	{ return fstarpu_callback_arg; }
+	else if	(!strcmp(s, "FSTARPU_CALLBACK_WITH_ARG_NFREE"))	{ return fstarpu_callback_with_arg_nfree; }
+	else if	(!strcmp(s, "FSTARPU_CALLBACK_ARG"))		{ return fstarpu_callback_arg; }
+	else if	(!strcmp(s, "FSTARPU_CALLBACK_ARG_NFREE"))	{ return fstarpu_callback_arg_nfree; }
 	else if	(!strcmp(s, "FSTARPU_PROLOGUE_CALLBACK"))	{ return fstarpu_prologue_callback; }
 	else if	(!strcmp(s, "FSTARPU_PROLOGUE_CALLBACK_ARG"))	{ return fstarpu_prologue_callback_arg; }
+	else if	(!strcmp(s, "FSTARPU_PROLOGUE_CALLBACK_ARG_NFREE"))	{ return fstarpu_prologue_callback_arg_nfree; }
 	else if	(!strcmp(s, "FSTARPU_PROLOGUE_CALLBACK_POP"))	{ return fstarpu_prologue_callback_pop; }
 	else if	(!strcmp(s, "FSTARPU_PROLOGUE_CALLBACK_POP_ARG"))	{ return fstarpu_prologue_callback_pop_arg; }
+	else if	(!strcmp(s, "FSTARPU_PROLOGUE_CALLBACK_POP_ARG_NFREE"))	{ return fstarpu_prologue_callback_pop_arg_nfree; }
 	else if	(!strcmp(s, "FSTARPU_PRIORITY"))	{ return fstarpu_priority; }
 	else if	(!strcmp(s, "FSTARPU_EXECUTE_ON_NODE"))	{ return fstarpu_execute_on_node; }
 	else if	(!strcmp(s, "FSTARPU_EXECUTE_ON_DATA"))	{ return fstarpu_execute_on_data; }

src/util/starpu_task_insert_utils.c

@@ -125,10 +125,19 @@ int _starpu_codelet_pack_args(void **arg_buffer, size_t *arg_buffer_size, va_lis
 			va_arg(varg_list, _starpu_callback_func_t);
 			va_arg(varg_list, void *);
 		}
+		else if (arg_type==STARPU_CALLBACK_WITH_ARG_NFREE)
+		{
+			va_arg(varg_list, _starpu_callback_func_t);
+			va_arg(varg_list, void *);
+		}
 		else if (arg_type==STARPU_CALLBACK_ARG)
 		{
 			(void)va_arg(varg_list, void *);
 		}
+		else if (arg_type==STARPU_CALLBACK_ARG_NFREE)
+		{
+			(void)va_arg(varg_list, void *);
+		}
 		else if (arg_type==STARPU_PROLOGUE_CALLBACK)
 		{
 			va_arg(varg_list, _starpu_callback_func_t);
@@ -137,6 +146,10 @@ int _starpu_codelet_pack_args(void **arg_buffer, size_t *arg_buffer_size, va_lis
 		{
 			(void)va_arg(varg_list, void *);
 		}
+		else if (arg_type==STARPU_PROLOGUE_CALLBACK_ARG_NFREE)
+		{
+			(void)va_arg(varg_list, void *);
+		}
 		else if (arg_type==STARPU_PROLOGUE_CALLBACK_POP)
 		{
 			va_arg(varg_list, _starpu_callback_func_t);
@@ -145,6 +158,10 @@ int _starpu_codelet_pack_args(void **arg_buffer, size_t *arg_buffer_size, va_lis
 		{
 			(void)va_arg(varg_list, void *);
 		}
+		else if (arg_type==STARPU_PROLOGUE_CALLBACK_POP_ARG_NFREE)
+		{
+			(void)va_arg(varg_list, void *);
+		}
 		else if (arg_type==STARPU_PRIORITY)
 		{
 			(void)va_arg(varg_list, int);
@@ -433,11 +450,22 @@ int _starpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task *ta
 			task->callback_arg = va_arg(varg_list, void *);
 			task->callback_arg_free = 1;
 		}
+		else if (arg_type==STARPU_CALLBACK_WITH_ARG_NFREE)
+		{
+			task->callback_func = va_arg(varg_list, _starpu_callback_func_t);
+			task->callback_arg = va_arg(varg_list, void *);
+			task->callback_arg_free = 0;
+		}
 		else if (arg_type==STARPU_CALLBACK_ARG)
 		{
 			task->callback_arg = va_arg(varg_list, void *);
 			task->callback_arg_free = 1;
 		}
+		else if (arg_type==STARPU_CALLBACK_ARG_NFREE)
+		{
+			task->callback_arg = va_arg(varg_list, void *);
+			task->callback_arg_free = 0;
+		}
 		else if (arg_type==STARPU_PROLOGUE_CALLBACK)
 		{
 			task->prologue_callback_func = va_arg(varg_list, _starpu_callback_func_t);
@@ -447,6 +475,11 @@ int _starpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task *ta
 			task->prologue_callback_arg = va_arg(varg_list, void *);
 			task->prologue_callback_arg_free = 1;
 		}
+		else if (arg_type==STARPU_PROLOGUE_CALLBACK_ARG_NFREE)
+		{
+			task->prologue_callback_arg = va_arg(varg_list, void *);
+			task->prologue_callback_arg_free = 0;
+		}
 		else if (arg_type==STARPU_PROLOGUE_CALLBACK_POP)
 		{
 			task->prologue_callback_pop_func = va_arg(varg_list, _starpu_callback_func_t);
@@ -456,6 +489,11 @@ int _starpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task *ta
 			task->prologue_callback_pop_arg = va_arg(varg_list, void *);
 			task->prologue_callback_pop_arg_free = 1;
 		}
+		else if (arg_type==STARPU_PROLOGUE_CALLBACK_POP_ARG_NFREE)
+		{
+			task->prologue_callback_pop_arg = va_arg(varg_list, void *);
+			task->prologue_callback_pop_arg_free = 0;
+		}
 		else if (arg_type==STARPU_PRIORITY)
 		{
 			/* Followed by a priority level */
@@ -708,12 +746,26 @@ int _fstarpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task *t
 			task->callback_arg = arglist[arg_i];
 			task->callback_arg_free = 1;
 		}
+		else if (arg_type == STARPU_CALLBACK_WITH_ARG_NFREE)
+		{
+			arg_i++;
+			task->callback_func = (_starpu_callback_func_t)arglist[arg_i];
+			arg_i++;
+			task->callback_arg = arglist[arg_i];
+			task->callback_arg_free = 0;
+		}
 		else if (arg_type == STARPU_CALLBACK_ARG)
 		{
 			arg_i++;
 			task->callback_arg = arglist[arg_i];
 			task->callback_arg_free = 1;
 		}
+		else if (arg_type == STARPU_CALLBACK_ARG_NFREE)
+		{
+			arg_i++;
+			task->callback_arg = arglist[arg_i];
+			task->callback_arg_free = 0;
+		}
 		else if (arg_type == STARPU_PROLOGUE_CALLBACK)
 		{
 			arg_i++;
@@ -725,6 +777,12 @@ int _fstarpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task *t
 			task->prologue_callback_arg = arglist[arg_i];
 			task->prologue_callback_arg_free = 1;
 		}
+		else if (arg_type == STARPU_PROLOGUE_CALLBACK_ARG_NFREE)
+		{
+			arg_i++;
+			task->prologue_callback_arg = arglist[arg_i];
+			task->prologue_callback_arg_free = 0;
+		}
 		else if (arg_type == STARPU_PROLOGUE_CALLBACK_POP)
 		{
 			arg_i++;
@@ -736,6 +794,12 @@ int _fstarpu_task_insert_create(struct starpu_codelet *cl, struct starpu_task *t
 			task->prologue_callback_pop_arg = arglist[arg_i];
 			task->prologue_callback_pop_arg_free = 1;
 		}
+		else if (arg_type == STARPU_PROLOGUE_CALLBACK_POP_ARG_NFREE)
+		{
+			arg_i++;
+			task->prologue_callback_pop_arg = arglist[arg_i];
+			task->prologue_callback_pop_arg_free = 0;
+		}
 		else if (arg_type == STARPU_PRIORITY)
 		{
 			arg_i++;

tests/main/codelet_null_callback.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2013-2015,2017                           CNRS
+ * Copyright (C) 2013-2015,2017,2019                      CNRS
  * Copyright (C) 2015,2016                                Université de Bordeaux
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -71,25 +71,25 @@ int main(int argc, char **argv)
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
 
 	ret = starpu_task_insert(NULL,
-				 STARPU_CALLBACK_WITH_ARG, callback, &x,
+				 STARPU_CALLBACK_WITH_ARG_NFREE, callback, &x,
 				 0);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
 
 	ret = starpu_task_insert(NULL,
 				 STARPU_CALLBACK, callback2,
-				 STARPU_CALLBACK_ARG, &x2,
+				 STARPU_CALLBACK_ARG_NFREE, &x2,
 				 0);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
 
 	ret = starpu_task_insert(NULL,
 				 STARPU_PROLOGUE_CALLBACK, prologue_callback,
-				 STARPU_PROLOGUE_CALLBACK_ARG, &y,
+				 STARPU_PROLOGUE_CALLBACK_ARG_NFREE, &y,
 				 0);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
 
 	ret = starpu_task_insert(NULL,
 				 STARPU_PROLOGUE_CALLBACK_POP, prologue_callback_pop,
-				 STARPU_PROLOGUE_CALLBACK_POP_ARG, &z,
+				 STARPU_PROLOGUE_CALLBACK_POP_ARG_NFREE, &z,
 				 0);
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
 

tests/sched_ctx/sched_ctx_hierarchy.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2017                                     CNRS
+ * Copyright (C) 2017, 2019                               CNRS
  * Copyright (C) 2017                                     Inria
  * Copyright (C) 2017                                     Université de Bordeaux
  *
@@ -21,7 +21,8 @@
 
 void free_codelet(void *arg)
 {
-	free(arg);
+	// The argument of the function is automatically freed by StarPU
+	//	free(arg);
 }
 
 void func_cpu_bis(void *descr[], void *_args)