Rename starpu_task_deinit to starpu_task_clean.

doc/chapters/basic-api.texi

@@ -1571,7 +1571,7 @@ submitted if it has not been properly initialized.
 Initialize @var{task} with default values. This function is implicitly
 called by @code{starpu_task_create}. By default, tasks initialized with
 @code{starpu_task_init} must be deinitialized explicitly with
-@code{starpu_task_deinit}. Tasks can also be initialized statically,
+@code{starpu_task_clean}. Tasks can also be initialized statically,
 using @code{STARPU_TASK_INITIALIZER} defined below.
 @end deftypefun
 
@@ -1593,19 +1593,13 @@ by the task have to be freed by calling
 @end deftypefun
 
 @deftypefun void starpu_task_clean ({struct starpu_task} *@var{task})
-Clean the task, unset internally initialised fields and let the values
-previously set by the user, like codelet and handles, unchanged.
-It is useful for statically allocated tasks ; when the user wants to execute
-the same operation several times with as least overhead as possible.
-It should be called after explicitly waiting for the task:
-@code{starpu_task_wait} or @code{starpu_task_wait_for_all}.
-@end deftypefun
-
-@deftypefun void starpu_task_deinit ({struct starpu_task} *@var{task})
 Release all the structures automatically allocated to execute @var{task}, but
-not the task structure itself. It is thus useful for statically allocated tasks
-for instance.  It is called automatically by @code{starpu_task_destroy}.  It
-has to be called only after explicitly waiting for the task or after
+not the task structure itself and values set by the user remain unchanged.
+It is thus useful for statically allocated tasks for instance.
+It is also useful when the user wants to execute the same operation several
+times with as least overhead as possible.
+It is called automatically by @code{starpu_task_destroy}.
+It has to be called only after explicitly waiting for the task or after
 @code{starpu_shutdown} (waiting for the callback is not enough, since starpu
 still manipulates the task after calling the callback).
 @end deftypefun

doc/chapters/perf-optimization.texi

@@ -241,7 +241,7 @@ void feed(void) @{
 	starpu_vector_data_register(&handle, -1, 0, measure->size, sizeof(float));
 	task.handles[0] = handle;
 	starpu_perfmodel_update_history(&perf_model, &task, STARPU_CUDA_DEFAULT + measure->cudadev, 0, measure->implementation, measure->time);
-	starpu_task_deinit(&task);
+	starpu_task_clean(&task);
 	starpu_data_unregister(handle);
     @}
 @}

include/starpu_deprecated_api.h

@@ -52,7 +52,8 @@ typedef enum starpu_access_mode starpu_access_mode;
 #define starpu_get_handle_interface_id starpu_handle_get_interface_id
 #define starpu_get_current_task        starpu_task_get_current
 #define starpu_unpack_cl_args          starpu_codelet_unpack_args
-#define starpu_pack_cl_args            starpu_codelet_pack_args
+#define starpu_pack_cl_args   	       starpu_codelet_pack_args
+#define starpu_task_deinit	       starpu_task_clean
 
 #ifdef __cplusplus
 }

include/starpu_task.h

@@ -266,14 +266,9 @@ void starpu_task_init(struct starpu_task *task);
 
 /* Release all the structures automatically allocated to execute the task. This
  * is called implicitely by starpu_task_destroy, but the task structure itself
- * is not freed. This should be used for statically allocated tasks for
- * instance. */
-void starpu_task_deinit(struct starpu_task *task);
-
-/* Clean the task, unset internally initialised fields and let the values
- * previously set by the user, like codelet and handles, unchanged.
- * It is useful for statically allocated tasks, when submitting the same task
- * several times with as least overhead as possible is needed.
+ * is not freed. Values previously set by the user remain unchanged.
+ * This should be used for statically allocated tasks for instance.
+ * It should also be used for submitting the same task several times.
  */
 void starpu_task_clean(struct starpu_task *task);
 

src/core/perfmodel/perfmodel.c

@@ -292,7 +292,7 @@ double starpu_task_expected_conversion_time(struct starpu_task *task,
 		handle->refcnt--;
 		handle->busy_count--;
 		_starpu_spin_unlock(&handle->header_lock);
-		starpu_task_deinit(conversion_task);
+		starpu_task_clean(conversion_task);
 		free(conversion_task);
 	}
 

src/core/task.c

@@ -66,8 +66,10 @@ void starpu_task_init(struct starpu_task *task)
 }
 
 /* Free all the ressources allocated for a task, without deallocating the task
- * structure itself (this is required for statically allocated tasks). */
-void starpu_task_deinit(struct starpu_task *task)
+ * structure itself (this is required for statically allocated tasks).
+ * All values previously set by the user, like codelet and handles, remain
+ * unchanged */
+void starpu_task_clean(struct starpu_task *task)
 {
 	STARPU_ASSERT(task);
 
@@ -91,26 +93,6 @@ void starpu_task_deinit(struct starpu_task *task)
 	}
 }
 
-/* Unset fields internally initialised by StarPU and which must be removed
- * from a submission to the other.
- * All values previously set by the user, like codelet and handles, remain
- * unchanged. Profiling is not modified to keep previously processed profiles
- * as the task will execute the same functions.
- */
-void starpu_task_clean(struct starpu_task *task)
-{
-	STARPU_ASSERT(task);
-
-	struct _starpu_job *j = (struct _starpu_job *) task->starpu_private;
-
-	/* As a new submission means new job we must unset it */
-	if (j)
-	{
-		_starpu_job_destroy(j);
-		task->starpu_private = NULL;
-	}
-}
-
 struct starpu_task * __attribute__((malloc)) starpu_task_create(void)
 {
 	struct starpu_task *task;
@@ -144,7 +126,7 @@ void _starpu_task_destroy(struct starpu_task *task)
    }
    else
    {
-	   starpu_task_deinit(task);
+	   starpu_task_clean(task);
 	   /* TODO handle the case of task with detach = 1 and destroy = 1 */
 	   /* TODO handle the case of non terminated tasks -> return -EINVAL */
 	   free(task);

tests/main/regenerate.c

@@ -121,7 +121,7 @@ int main(int argc, char **argv)
 	starpu_shutdown();
 
 	/* Cleanup the statically allocated tasks after shutdown, as StarPU is still working on it after the callback */
-	starpu_task_deinit(&task);
+	starpu_task_clean(&task);
 
 	return EXIT_SUCCESS;
 

tests/main/static_restartable.c

@@ -103,7 +103,7 @@ int main(int argc, char **argv)
 	FPRINTF(stderr, "Total: %f secs\n", timing/1000000);
 	FPRINTF(stderr, "Per task: %f usecs\n", timing/ntasks);
 
-	starpu_task_deinit(&task);
+	starpu_task_clean(&task);
 	starpu_shutdown();
 
 	return EXIT_SUCCESS;

tests/main/static_restartable_tag.c

@@ -110,7 +110,7 @@ int main(int argc, char **argv)
 	starpu_shutdown();
 
 	/* Cleanup the statically allocated tasks after shutdown, as StarPU is still working on it after the callback */
-	starpu_task_deinit(&task);
+	starpu_task_clean(&task);
 
 	return EXIT_SUCCESS;
 

tests/main/static_restartable_using_initializer.c

@@ -92,7 +92,7 @@ int main(int argc, char **argv)
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_wait");
 	}
 
-	starpu_task_deinit(&task);
+	starpu_task_clean(&task);
 	gettimeofday(&end, NULL);
 
 	timing = (double)((end.tv_sec - start.tv_sec)*1000000

tests/main/subgraph_repeat.c

@@ -135,10 +135,10 @@ int main(int argc, char **argv)
 	starpu_shutdown();
 
 	/* Cleanup the statically allocated tasks after shutdown, as StarPU is still working on it after the callback */
-	starpu_task_deinit(&taskA);
-	starpu_task_deinit(&taskB);
-	starpu_task_deinit(&taskC);
-	starpu_task_deinit(&taskD);
+	starpu_task_clean(&taskA);
+	starpu_task_clean(&taskB);
+	starpu_task_clean(&taskC);
+	starpu_task_clean(&taskD);
 
 	return EXIT_SUCCESS;
 

tests/main/subgraph_repeat_regenerate.c

@@ -141,10 +141,10 @@ int main(int argc, char **argv)
 	starpu_shutdown();
 
 	/* Cleanup the statically allocated tasks after shutdown, as StarPU is still working on it after the callback */
-	starpu_task_deinit(&taskA);
-	starpu_task_deinit(&taskB);
-	starpu_task_deinit(&taskC);
-	starpu_task_deinit(&taskD);
+	starpu_task_clean(&taskA);
+	starpu_task_clean(&taskB);
+	starpu_task_clean(&taskC);
+	starpu_task_clean(&taskD);
 
 	return EXIT_SUCCESS;
 

tests/main/subgraph_repeat_regenerate_tag.c

@@ -156,10 +156,10 @@ int main(int argc, char **argv)
 	starpu_shutdown();
 
 	/* Cleanup the statically allocated tasks after shutdown, as StarPU is still working on it after the callback */
-	starpu_task_deinit(&taskA);
-	starpu_task_deinit(&taskB);
-	starpu_task_deinit(&taskC);
-	starpu_task_deinit(&taskD);
+	starpu_task_clean(&taskA);
+	starpu_task_clean(&taskB);
+	starpu_task_clean(&taskC);
+	starpu_task_clean(&taskD);
 
 	return EXIT_SUCCESS;
 

tests/main/subgraph_repeat_tag.c

@@ -141,10 +141,10 @@ int main(int argc, char **argv)
 	starpu_shutdown();
 
 	/* Cleanup the statically allocated tasks after shutdown, as StarPU is still working on it after the callback */
-	starpu_task_deinit(&taskA);
-	starpu_task_deinit(&taskB);
-	starpu_task_deinit(&taskC);
-	starpu_task_deinit(&taskD);
+	starpu_task_clean(&taskA);
+	starpu_task_clean(&taskB);
+	starpu_task_clean(&taskC);
+	starpu_task_clean(&taskD);
 
 	return EXIT_SUCCESS;
 

tests/main/wait_all_regenerable_tasks.c

@@ -106,7 +106,7 @@ int main(int argc, char **argv)
 
 	ret = starpu_task_wait_for_all();
 	for (i = 0; i < K; i++)
-		starpu_task_deinit(&task[i]);
+		starpu_task_clean(&task[i]);
 
 	STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_wait_for_all");
 

tests/perfmodels/feed.c

@@ -75,7 +75,7 @@ int main(int argc, char **argv)
 		/* Simulate Slow GPU */
 		starpu_perfmodel_update_history(&model, &task, STARPU_CUDA_DEFAULT + 1, 0, 0, measured_slow);
 		starpu_perfmodel_update_history(&nl_model, &task, STARPU_CUDA_DEFAULT + 1, 0, 0, measured_slow);
-		starpu_task_deinit(&task);
+		starpu_task_clean(&task);
 		starpu_data_unregister(handle);
 	}
 

tools/dev/rename.sed

@@ -141,3 +141,4 @@ s/\bstarpu_get_handle_interface_id\b/starpu_handle_get_interface_id/g
 s/\bstarpu_get_current_task\b/starpu_task_get_current/g
 s/\bstarpu_pack_cl_args\b/starpu_codelet_pack_args/g
 s/\bstarpu_unpack_cl_args\b/starpu_codelet_unpack_args/g
+s/\bstarpu_task_deinit\b/starpu_task_clean/g