include: doc: update function prototypes to be similar in doc and include

doc/chapters/basic-api.texi

@@ -300,9 +300,9 @@ over the entire machine, so that we can maintain data consistency and locate
 data replicates for instance.
 @end deftp
 
-@deftypefun void starpu_data_register (starpu_data_handle_t *@var{handleptr}, uint32_t @var{home_node}, void *@var{interface}, {struct starpu_data_interface_ops} *@var{ops})
+@deftypefun void starpu_data_register (starpu_data_handle_t *@var{handleptr}, uint32_t @var{home_node}, void *@var{data_interface}, {struct starpu_data_interface_ops} *@var{ops})
 Register a piece of data into the handle located at the @var{handleptr}
-address. The @var{interface} buffer contains the initial description of the
+address. The @var{data_interface} buffer contains the initial description of the
 data in the home node. The @var{ops} argument is a pointer to a structure
 describing the different methods used to manipulate this type of interface. See
 @ref{struct starpu_data_interface_ops} for more details on this structure.
@@ -461,8 +461,8 @@ starpu_variable_data_register(&var_handle, 0, (uintptr_t)&var, sizeof(var));
 @end cartouche
 @end deftypefun
 
-@deftypefun void starpu_vector_data_register ({starpu_data_handle_t *}@var{handle}, uint32_t @var{home_node}, uintptr_t @var{ptr}, uint32_t @var{count}, size_t @var{size})
+@deftypefun void starpu_vector_data_register ({starpu_data_handle_t *}@var{handle}, uint32_t @var{home_node}, uintptr_t @var{ptr}, uint32_t @var{nx}, size_t @var{elemsize})
-Register the @var{count} @var{size}-byte elements pointed to by
+Register the @var{nx} @var{elemsize}-byte elements pointed to by
 @var{ptr} and initialize @var{handle} to represent it.
 
 @cartouche
@@ -475,8 +475,8 @@ starpu_vector_data_register(&vector_handle, 0, (uintptr_t)vector, NX,
 @end cartouche
 @end deftypefun
 
-@deftypefun void starpu_matrix_data_register ({starpu_data_handle_t *}@var{handle}, uint32_t @var{home_node}, uintptr_t @var{ptr}, uint32_t @var{ld}, uint32_t @var{nx}, uint32_t @var{ny}, size_t @var{size})
+@deftypefun void starpu_matrix_data_register ({starpu_data_handle_t *}@var{handle}, uint32_t @var{home_node}, uintptr_t @var{ptr}, uint32_t @var{ld}, uint32_t @var{nx}, uint32_t @var{ny}, size_t @var{elemsize})
-Register the @var{nx}x@var{ny} 2D matrix of @var{size}-byte elements
+Register the @var{nx}x@var{ny} 2D matrix of @var{elemsize}-byte elements
 pointed by @var{ptr} and initialize @var{handle} to represent it.
 @var{ld} specifies the number of extra elements present at the end of
 each row; a non-zero @var{ld} adds padding, which can be useful for
@@ -493,8 +493,8 @@ starpu_matrix_data_register(&matrix_handle, 0, (uintptr_t)matrix,
 @end cartouche
 @end deftypefun
 
-@deftypefun void starpu_block_data_register ({starpu_data_handle_t *}@var{handle}, uint32_t @var{home_node}, uintptr_t @var{ptr}, uint32_t @var{ldy}, uint32_t @var{ldz}, uint32_t @var{nx}, uint32_t @var{ny}, uint32_t @var{nz}, size_t @var{size})
+@deftypefun void starpu_block_data_register ({starpu_data_handle_t *}@var{handle}, uint32_t @var{home_node}, uintptr_t @var{ptr}, uint32_t @var{ldy}, uint32_t @var{ldz}, uint32_t @var{nx}, uint32_t @var{ny}, uint32_t @var{nz}, size_t @var{elemsize})
-Register the @var{nx}x@var{ny}x@var{nz} 3D matrix of @var{size}-byte
+Register the @var{nx}x@var{ny}x@var{nz} 3D matrix of @var{elemsize}-byte
 elements pointed by @var{ptr} and initialize @var{handle} to represent
 it.  Again, @var{ldy} and @var{ldz} specify the number of extra elements
 present at the end of each row or column.
@@ -1472,7 +1472,7 @@ starpu_tag_declare_deps_array((starpu_tag_t)0x1, 2, tag_array);
 @end cartouche
 @end deftypefun
 
-@deftypefun void starpu_tag_wait (starpu_tag_t @var{id})
+@deftypefun int starpu_tag_wait (starpu_tag_t @var{id})
 This function blocks until the task associated to tag @var{id} has been
 executed. This is a blocking call which must therefore not be called within
 tasks or callbacks, but only from the application directly.  It is possible to
@@ -1483,7 +1483,7 @@ data structure was freed (e.g. if the @code{destroy} flag of the
 @code{starpu_task} was enabled).
 @end deftypefun
 
-@deftypefun void starpu_tag_wait_array (unsigned @var{ntags}, starpu_tag_t *@var{id})
+@deftypefun int starpu_tag_wait_array (unsigned @var{ntags}, starpu_tag_t *@var{id})
 This function is similar to @code{starpu_tag_wait} except that it blocks until
 @emph{all} the @var{ntags} tags contained in the @var{id} array are
 terminated.
@@ -1528,10 +1528,6 @@ mode of a specific data handle with the
 Return the default sequential consistency flag
 @end deftypefun
 
-@deftypefun unsigned starpu_data_set_default_sequential_consistency_flag (void)
-This function returns the current default sequential consistency flag.
-@end deftypefun
-
 @deftypefun void starpu_data_set_sequential_consistency_flag (starpu_data_handle_t @var{handle}, unsigned @var{flag})
 Sets the data consistency mode associated to a data handle. The consistency
 mode set using this function has the priority over the default mode which can
@@ -1632,12 +1628,13 @@ case it depends on the architecture-specific implementation.
 loads a given performance model. The @var{model} structure has to be completely zero, and will be filled with the information saved in @code{~/.starpu}.
 @end deftypefun
 
-@deftypefun void starpu_perfmodel_debugfilepath ({struct starpu_perfmodel} *@var{model}, {enum starpu_perf_archtype} @var{arch}, char *@var{path}, size_t @var{maxlen})
+@deftypefun void starpu_perfmodel_debugfilepath ({struct starpu_perfmodel} *@var{model}, {enum starpu_perf_archtype} @var{arch}, char *@var{path}, size_t @var{maxlen}, unsigned nimpl)
-returns the path to the debugginf information for the performance model.
+returns the path to the debugging information for the performance model.
 @end deftypefun
 
-@deftypefun void starpu_perfmodel_get_arch_name ({enum starpu_perf_archtype} @var{arch}, char *@var{archname}, size_t @var{maxlen})
+@deftypefun void starpu_perfmodel_get_arch_name ({enum starpu_perf_archtype} @var{arch}, char *@var{archname}, size_t @var{maxlen}, unsigned nimpl)
 returns the architecture name for @var{arch}.
+todo
 @end deftypefun
 
 @deftypefun void starpu_force_bus_sampling (void)
@@ -1777,7 +1774,7 @@ TODO
 @node CUDA extensions
 @section CUDA extensions
 
-@deftypefun {cudaStream_t *} starpu_cuda_get_local_stream (void)
+@deftypefun cudaStream_t starpu_cuda_get_local_stream (void)
 This function gets the current worker's CUDA stream.
 StarPU provides a stream for every CUDA device controlled by StarPU. This
 function is only provided for convenience so that programmers can easily use
@@ -1872,12 +1869,12 @@ relocation purpose for instance).
 todo
 @end deftp
 
-@deftypefun int starpu_opencl_load_opencl_from_file (char *@var{source_file_name}, {struct starpu_opencl_program} *@var{opencl_programs}, {const char}* @var{build_options})
+@deftypefun int starpu_opencl_load_opencl_from_file ({const char} *@var{source_file_name}, {struct starpu_opencl_program} *@var{opencl_programs}, {const char}* @var{build_options})
 @anchor{starpu_opencl_load_opencl_from_file}
 This function compiles an OpenCL source code stored in a file.
 @end deftypefun
 
-@deftypefun int starpu_opencl_load_opencl_from_string (char *@var{opencl_program_source}, {struct starpu_opencl_program} *@var{opencl_programs}, {const char}* @var{build_options})
+@deftypefun int starpu_opencl_load_opencl_from_string ({const char} *@var{opencl_program_source}, {struct starpu_opencl_program} *@var{opencl_programs}, {const char}* @var{build_options})
 This function compiles an OpenCL source code stored in a string.
 @end deftypefun
 
@@ -1888,7 +1885,7 @@ This function unloads an OpenCL compiled code.
 @node Loading OpenCL kernels
 @subsection Loading OpenCL kernels
 
-@deftypefun int starpu_opencl_load_kernel (cl_kernel *@var{kernel}, cl_command_queue *@var{queue}, {struct starpu_opencl_program} *@var{opencl_programs}, char *@var{kernel_name}, int @var{devid})
+@deftypefun int starpu_opencl_load_kernel (cl_kernel *@var{kernel}, cl_command_queue *@var{queue}, {struct starpu_opencl_program} *@var{opencl_programs}, {const char} *@var{kernel_name}, int @var{devid})
 TODO
 @end deftypefun
 

doc/chapters/mpi-support.texi

@@ -214,7 +214,7 @@ Tell StarPU-MPI which MPI tag to use when exchanging the data.
 Returns the MPI tag to be used when exchanging the data.
 @end deftypefun
 
-@deftypefun int starpu_data_set_rank (starpu_data_handle_t @var{handle}, int @var{mpi_rank})
+@deftypefun int starpu_data_set_rank (starpu_data_handle_t @var{handle}, int @var{rank})
 Tell StarPU-MPI which MPI node "owns" a given data, that is, the node which will
 always keep an up-to-date value, and will by default execute tasks which write
 to it.
@@ -224,8 +224,8 @@ to it.
 Returns the last value set by @code{starpu_data_set_rank}.
 @end deftypefun
 
-@deftypefun void starpu_mpi_insert_task (MPI_Comm @var{comm}, struct starpu_codelet *@var{cl}, ...)
+@deftypefun int starpu_mpi_insert_task (MPI_Comm @var{comm}, struct starpu_codelet *@var{codelet}, ...)
-Create and submit a task corresponding to @var{cl} with the following
+Create and submit a task corresponding to @var{codelet} with the following
 arguments.  The argument list must be zero-terminated.
 
 The arguments following the codelets are the same types as for the

include/starpu_data.h

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2010-2011  Université de Bordeaux 1
- * Copyright (C) 2010, 2011  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011, 2012  Centre National de la Recherche Scientifique
  *
  * StarPU is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -54,13 +54,12 @@ void starpu_data_unregister_no_coherency(starpu_data_handle_t handle);
 
 /* Destroy all data replicates. After data invalidation, the first access to
  * the handle must be performed in write-only mode. */
-void starpu_data_invalidate(starpu_data_handle_t);
+void starpu_data_invalidate(starpu_data_handle_t handle);
 
 void starpu_data_advise_as_important(starpu_data_handle_t handle, unsigned is_important);
 
 int starpu_data_acquire(starpu_data_handle_t handle, enum starpu_access_mode mode);
-int starpu_data_acquire_cb(starpu_data_handle_t handle,
+int starpu_data_acquire_cb(starpu_data_handle_t handle, enum starpu_access_mode mode, void (*callback)(void *), void *arg);
-			   enum starpu_access_mode mode, void (*callback)(void *), void *arg);
 #ifdef __GCC__
 #  define STARPU_DATA_ACQUIRE_CB(handle, mode, code) do \
 	{ \						\
@@ -122,9 +121,7 @@ void starpu_data_query_status(starpu_data_handle_t handle, int memory_node, int
 
 struct starpu_codelet;
 
-void starpu_data_set_reduction_methods(starpu_data_handle_t handle,
+void starpu_data_set_reduction_methods(starpu_data_handle_t handle, struct starpu_codelet *redux_cl, struct starpu_codelet *init_cl);
-					struct starpu_codelet *redux_cl,
-					struct starpu_codelet *init_cl);
 
 int starpu_data_set_rank(starpu_data_handle_t handle, int rank);
 int starpu_data_get_rank(starpu_data_handle_t handle);

include/starpu_data_filters.h

@@ -2,7 +2,7 @@
  *
  * Copyright (C) 2010-2011  Université de Bordeaux 1
  * Copyright (C) 2010  Mehdi Juhoor <mjuhoor@gmail.com>
- * Copyright (C) 2010, 2011  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011, 2012  Centre National de la Recherche Scientifique
  *
  * StarPU is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -48,7 +48,7 @@ starpu_data_handle_t starpu_data_get_child(starpu_data_handle_t handle, unsigned
 /* unsigned list */
 starpu_data_handle_t starpu_data_get_sub_data(starpu_data_handle_t root_data, unsigned depth, ... );
 /* Same, but using va_list */
-starpu_data_handle_t starpu_data_vget_sub_data(starpu_data_handle_t root_data, unsigned depth, va_list pa );
+starpu_data_handle_t starpu_data_vget_sub_data(starpu_data_handle_t root_data, unsigned depth, va_list pa);
 
 /* struct starpu_data_filter * list */
 void starpu_data_map_filters(starpu_data_handle_t root_data, unsigned nfilters, ...);

include/starpu_data_interfaces.h

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2010-2011  Université de Bordeaux 1
- * Copyright (C) 2010, 2011  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011, 2012  Centre National de la Recherche Scientifique
  * Copyright (C) 2011-2012  Institut National de Recherche en Informatique et Automatique
  *
  * StarPU is free software; you can redistribute it and/or modify
@@ -134,9 +134,7 @@ struct starpu_data_interface_ops
 	struct starpu_multiformat_data_interface_ops* (*get_mf_ops)(void *data_interface);
 };
 
-void starpu_data_register(starpu_data_handle_t *handleptr, uint32_t home_node,
+void starpu_data_register(starpu_data_handle_t *handleptr, uint32_t home_node, void *data_interface, struct starpu_data_interface_ops *ops);
-				void *data_interface,
-				struct starpu_data_interface_ops *ops);
 
 /* Return the pointer associated with HANDLE on node NODE or NULL if HANDLE's
  * interface does not support this operation or data for this handle is not
@@ -173,9 +171,7 @@ struct starpu_matrix_interface
 	size_t elemsize;
 };
 
-void starpu_matrix_data_register(starpu_data_handle_t *handle, uint32_t home_node,
+void starpu_matrix_data_register(starpu_data_handle_t *handle, uint32_t home_node, uintptr_t ptr, uint32_t ld, uint32_t nx, uint32_t ny, size_t elemsize);
-                        uintptr_t ptr, uint32_t ld, uint32_t nx,
-                        uint32_t ny, size_t elemsize);
 uint32_t starpu_matrix_get_nx(starpu_data_handle_t handle);
 uint32_t starpu_matrix_get_ny(starpu_data_handle_t handle);
 uint32_t starpu_matrix_get_local_ld(starpu_data_handle_t handle);
@@ -207,9 +203,7 @@ struct starpu_block_interface
 	size_t elemsize;
 };
 
-void starpu_block_data_register(starpu_data_handle_t *handle, uint32_t home_node,
+void starpu_block_data_register(starpu_data_handle_t *handle, uint32_t home_node, uintptr_t ptr, uint32_t ldy, uint32_t ldz, uint32_t nx, uint32_t ny, uint32_t nz, size_t elemsize);
-                        uintptr_t ptr, uint32_t ldy, uint32_t ldz, uint32_t nx,
-                        uint32_t ny, uint32_t nz, size_t elemsize);
 uint32_t starpu_block_get_nx(starpu_data_handle_t handle);
 uint32_t starpu_block_get_ny(starpu_data_handle_t handle);
 uint32_t starpu_block_get_nz(starpu_data_handle_t handle);
@@ -239,8 +233,7 @@ struct starpu_vector_interface
 	size_t elemsize;
 };
 
-void starpu_vector_data_register(starpu_data_handle_t *handle, uint32_t home_node,
+void starpu_vector_data_register(starpu_data_handle_t *handle, uint32_t home_node, uintptr_t ptr, uint32_t nx, size_t elemsize);
-                        uintptr_t ptr, uint32_t nx, size_t elemsize);
 uint32_t starpu_vector_get_nx(starpu_data_handle_t handle);
 size_t starpu_vector_get_elemsize(starpu_data_handle_t handle);
 uintptr_t starpu_vector_get_local_ptr(starpu_data_handle_t handle);
@@ -260,8 +253,7 @@ struct starpu_variable_interface
 	/* No dev_handle, since it can not be filtered, offset will always be zero */
 };
 
-void starpu_variable_data_register(starpu_data_handle_t *handle, uint32_t home_node,
+void starpu_variable_data_register(starpu_data_handle_t *handle, uint32_t home_node, uintptr_t ptr, size_t size);
-                        uintptr_t ptr, size_t elemsize);
 size_t starpu_variable_get_elemsize(starpu_data_handle_t handle);
 uintptr_t starpu_variable_get_local_ptr(starpu_data_handle_t handle);
 
@@ -274,7 +266,7 @@ uintptr_t starpu_variable_get_local_ptr(starpu_data_handle_t handle);
  * abstract piece of data that is managed by the application internally: this
  * makes it possible to forbid the concurrent execution of different tasks
  * accessing the same "void" data in read-write concurrently. */
-void starpu_void_data_register(starpu_data_handle_t *handleptr);
+void starpu_void_data_register(starpu_data_handle_t *handle);
 
 /* CSR interface for sparse matrices (compressed sparse row representation) */
 struct starpu_csr_interface
@@ -292,8 +284,7 @@ struct starpu_csr_interface
 	size_t elemsize;
 };
 
-void starpu_csr_data_register(starpu_data_handle_t *handle, uint32_t home_node, uint32_t nnz, uint32_t nrow,
+void starpu_csr_data_register(starpu_data_handle_t *handle, uint32_t home_node, uint32_t nnz, uint32_t nrow, uintptr_t nzval, uint32_t *colind, uint32_t *rowptr, uint32_t firstentry, size_t elemsize);
-		uintptr_t nzval, uint32_t *colind, uint32_t *rowptr, uint32_t firstentry, size_t elemsize);
 uint32_t starpu_csr_get_nnz(starpu_data_handle_t handle);
 uint32_t starpu_csr_get_nrow(starpu_data_handle_t handle);
 uint32_t starpu_csr_get_firstentry(starpu_data_handle_t handle);
@@ -333,9 +324,7 @@ struct starpu_bcsr_interface
 	size_t elemsize;
 };
 
-void starpu_bcsr_data_register(starpu_data_handle_t *handle, uint32_t home_node, uint32_t nnz, uint32_t nrow,
+void starpu_bcsr_data_register(starpu_data_handle_t *handle, uint32_t home_node, uint32_t nnz, uint32_t nrow, uintptr_t nzval, uint32_t *colind, uint32_t *rowptr, uint32_t firstentry, uint32_t r, uint32_t c, size_t elemsize);
-		uintptr_t nzval, uint32_t *colind, uint32_t *rowptr, uint32_t firstentry, uint32_t r, uint32_t c, size_t elemsize);
-
 
 #define STARPU_BCSR_GET_NNZ(interface)        (((struct starpu_bcsr_interface *)(interface))->nnz)
 #define STARPU_BCSR_GET_NZVAL(interface)      (((struct starpu_bcsr_interface *)(interface))->nzval)
@@ -382,11 +371,7 @@ struct starpu_multiformat_interface
 	struct starpu_multiformat_data_interface_ops *ops;
 };
 
-void starpu_multiformat_data_register(starpu_data_handle_t *handle,
+void starpu_multiformat_data_register(starpu_data_handle_t *handle, uint32_t home_node, void *ptr, uint32_t nobjects, struct starpu_multiformat_data_interface_ops *format_ops);
-				      uint32_t home_node,
-				      void *ptr,
-				      uint32_t nobjects,
-				      struct starpu_multiformat_data_interface_ops *format_ops);
 
 #define STARPU_MULTIFORMAT_GET_PTR(interface)  (((struct starpu_multiformat_interface *)(interface))->cpu_ptr)
 

include/starpu_opencl.h

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2010, 2011  Université de Bordeaux 1
- * Copyright (C) 2010, 2011  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011, 2012  Centre National de la Recherche Scientifique
  *
  * StarPU is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -58,10 +58,8 @@ void starpu_opencl_get_queue(int devid, cl_command_queue *queue);
 void starpu_opencl_get_current_context(cl_context *context);
 void starpu_opencl_get_current_queue(cl_command_queue *queue);
 
-int starpu_opencl_load_opencl_from_file(const char *source_file_name, struct starpu_opencl_program *opencl_programs,
+int starpu_opencl_load_opencl_from_file(const char *source_file_name, struct starpu_opencl_program *opencl_programs, const char* build_options);
-					const char* build_options);
+int starpu_opencl_load_opencl_from_string(const char *opencl_program_source, struct starpu_opencl_program *opencl_programs, const char* build_options);
-int starpu_opencl_load_opencl_from_string(const char *opencl_program_source, struct starpu_opencl_program *opencl_programs,
-					  const char* build_options);
 int starpu_opencl_unload_opencl(struct starpu_opencl_program *opencl_programs);
 
 int starpu_opencl_load_kernel(cl_kernel *kernel, cl_command_queue *queue, struct starpu_opencl_program *opencl_programs, const char *kernel_name, int devid);
@@ -92,7 +90,7 @@ int starpu_opencl_collect_stats(cl_event event);
  * if (n != 2)
  * 	fprintf(stderr, "Error : %d\n", err);
  */
-int starpu_opencl_set_kernel_args(cl_int *error, cl_kernel *kernel, ...);
+int starpu_opencl_set_kernel_args(cl_int *err, cl_kernel *kernel, ...);
 
 #ifdef __cplusplus
 }

include/starpu_perfmodel.h

@@ -203,9 +203,8 @@ enum starpu_perf_archtype starpu_worker_get_perf_archtype(int workerid);
 /* This function is intended to be used by external tools that should read the
  * performance model files */
 int starpu_load_history_debug(const char *symbol, struct starpu_perfmodel *model);
-void starpu_perfmodel_debugfilepath(struct starpu_perfmodel *model,
+void starpu_perfmodel_debugfilepath(struct starpu_perfmodel *model, enum starpu_perf_archtype arch, char *path, size_t maxlen, unsigned nimpl);
-		enum starpu_perf_archtype arch, char *path, size_t maxlen, unsigned nimpl);
+void starpu_perfmodel_get_arch_name(enum starpu_perf_archtype arch, char *archname, size_t maxlen, unsigned nimpl);
-void starpu_perfmodel_get_arch_name(enum starpu_perf_archtype arch,	char *archname, size_t maxlen, unsigned nimpl);
 int starpu_list_models(FILE *output);
 
 void starpu_force_bus_sampling(void);

include/starpu_task_list.h

@@ -34,7 +34,7 @@ struct starpu_task_list
 void starpu_task_list_init(struct starpu_task_list *list);
 
 /* Push a task at the front of a list */
-void starpu_task_list_push_front(struct starpu_task_list *list,	struct starpu_task *task);
+void starpu_task_list_push_front(struct starpu_task_list *list, struct starpu_task *task);
 
 /* Push a task at the back of a list */
 void starpu_task_list_push_back(struct starpu_task_list *list, struct starpu_task *task);

include/starpu_util.h

@@ -223,8 +223,7 @@ void starpu_create_sync_task(starpu_tag_t sync_tag, unsigned ndeps, starpu_tag_t
  * (if enabled) or by calling starpu_task_wait_for_all(). If callback_func is
  * not NULL, this callback function is executed after the handle has been
  * copied, and it is given the callback_arg pointer as argument.*/
-int starpu_data_cpy(starpu_data_handle_t dst_handle, starpu_data_handle_t src_handle,
+int starpu_data_cpy(starpu_data_handle_t dst_handle, starpu_data_handle_t src_handle, int asynchronous, void (*callback_func)(void*), void *callback_arg);
-			int asynchronous, void (*callback_func)(void*), void *callback_arg);
 
 /* Constants used by the starpu_insert_task helper to determine the different types of argument */
 #define STARPU_VALUE		(1<<4)	/* Pointer to a constant value */