doc: fix deftypefun declarations.

   - Function name must be followed by a space (and  '(')
   - Multiple-words type name must be delimited by {}
   - Remove ; ending prototype function

doc/starpu.texi

@@ -2631,7 +2631,7 @@ indicates that the argument was NULL.
 
 @node starpu_shutdown
 @subsection @code{starpu_shutdown} -- Terminate StarPU
-@deftypefun void starpu_shutdown(void);
+@deftypefun void starpu_shutdown (void)
 This is StarPU termination method. It must be called at the end of the
 application: statistics and other post-mortem debugging information are not
 guaranteed to be available until this method has been called.
@@ -2657,14 +2657,14 @@ guaranteed to be available until this method has been called.
 
 @node starpu_worker_get_count
 @subsection @code{starpu_worker_get_count} -- Get the number of processing units
-@deftypefun unsigned starpu_worker_get_count(void);
+@deftypefun unsigned starpu_worker_get_count (void)
 This function returns the number of workers (i.e. processing units executing
 StarPU tasks). The returned value should be at most @code{STARPU_NMAXWORKERS}.
 @end deftypefun
 
 @node starpu_worker_get_count_by_type
 @subsection @code{starpu_worker_get_count_by_type} -- Get the number of processing units of a given type
-@deftypefun int starpu_worker_get_count_by_type(enum starpu_archtype @var{type});
+@deftypefun int starpu_worker_get_count_by_type ({enum starpu_archtype} @var{type})
 Returns the number of workers of the type indicated by the argument. A positive
 (or null) value is returned in case of success, @code{-EINVAL} indicates that
 the type is not valid otherwise.
@@ -2672,35 +2672,35 @@ the type is not valid otherwise.
 
 @node starpu_cpu_worker_get_count
 @subsection @code{starpu_cpu_worker_get_count} -- Get the number of CPU controlled by StarPU
-@deftypefun unsigned starpu_cpu_worker_get_count(void);
+@deftypefun unsigned starpu_cpu_worker_get_count (void)
 This function returns the number of CPUs controlled by StarPU. The returned
 value should be at most @code{STARPU_NMAXCPUS}.
 @end deftypefun
 
 @node starpu_cuda_worker_get_count
 @subsection @code{starpu_cuda_worker_get_count} -- Get the number of CUDA devices controlled by StarPU
-@deftypefun unsigned starpu_cuda_worker_get_count(void);
+@deftypefun unsigned starpu_cuda_worker_get_count (void)
 This function returns the number of CUDA devices controlled by StarPU. The returned
 value should be at most @code{STARPU_MAXCUDADEVS}.
 @end deftypefun
 
 @node starpu_opencl_worker_get_count
 @subsection @code{starpu_opencl_worker_get_count} -- Get the number of OpenCL devices controlled by StarPU
-@deftypefun unsigned starpu_opencl_worker_get_count(void);
+@deftypefun unsigned starpu_opencl_worker_get_count (void)
 This function returns the number of OpenCL devices controlled by StarPU. The returned
 value should be at most @code{STARPU_MAXOPENCLDEVS}.
 @end deftypefun
 
 @node starpu_spu_worker_get_count
 @subsection @code{starpu_spu_worker_get_count} -- Get the number of Cell SPUs controlled by StarPU
-@deftypefun unsigned starpu_opencl_worker_get_count(void);
+@deftypefun unsigned starpu_opencl_worker_get_count (void)
 This function returns the number of Cell SPUs controlled by StarPU.
 @end deftypefun
 
 
 @node starpu_worker_get_id
 @subsection @code{starpu_worker_get_id} -- Get the identifier of the current worker
-@deftypefun int starpu_worker_get_id(void);
+@deftypefun int starpu_worker_get_id (void)
 This function returns the identifier of the worker associated to the calling
 thread. The returned value is either -1 if the current context is not a StarPU
 worker (i.e. when called from the application outside a task or a callback), or
@@ -2709,7 +2709,7 @@ an integer between 0 and @code{starpu_worker_get_count() - 1}.
 
 @node starpu_worker_get_ids_by_type
 @subsection @code{starpu_worker_get_ids_by_type} -- Get the list of identifiers of workers with a given type
-@deftypefun int starpu_worker_get_ids_by_type(enum starpu_archtype @var{type}, int *@var{workerids}, int @var{maxsize});
+@deftypefun int starpu_worker_get_ids_by_type ({enum starpu_archtype} @var{type}, int *@var{workerids}, int @var{maxsize})
 Fill the workerids array with the identifiers of the workers that have the type
 indicated in the first argument. The maxsize argument indicates the size of the
 workids array. The returned value gives the number of identifiers that were put
@@ -2722,7 +2722,7 @@ by passing a value greater or equal to @code{STARPU_NMAXWORKERS}.
 
 @node starpu_worker_get_devid
 @subsection @code{starpu_worker_get_devid} -- Get the device identifier of a worker
-@deftypefun int starpu_worker_get_devid(int @var{id});
+@deftypefun int starpu_worker_get_devid (int @var{id})
 This functions returns the device id of the worker associated to an identifier
 (as returned by the @code{starpu_worker_get_id} function). In the case of a
 CUDA worker, this device identifier is the logical device identifier exposed by
@@ -2734,7 +2734,7 @@ worker was bound; this identifier is either provided by the OS or by the
 
 @node starpu_worker_get_type
 @subsection @code{starpu_worker_get_type} -- Get the type of processing unit associated to a worker
-@deftypefun {enum starpu_archtype} starpu_worker_get_type(int @var{id});
+@deftypefun {enum starpu_archtype} starpu_worker_get_type (int @var{id})
 This function returns the type of worker associated to an identifier (as
 returned by the @code{starpu_worker_get_id} function). The returned value
 indicates the architecture of the worker: @code{STARPU_CPU_WORKER} for a CPU
@@ -2747,7 +2747,7 @@ identifier is unspecified.
 @node starpu_worker_get_name
 @subsection @code{starpu_worker_get_name} -- Get the name of a worker
 
-@deftypefun void starpu_worker_get_name(int @var{id}, char *@var{dst}, size_t @var{maxlen});
+@deftypefun void starpu_worker_get_name (int @var{id}, char *@var{dst}, size_t @var{maxlen})
 StarPU associates a unique human readable string to each processing unit. This
 function copies at most the @code{maxlen} first bytes of the unique string
 associated to a worker identified by its identifier @code{id} into the
@@ -2758,7 +2758,7 @@ function on an invalid identifier results in an unspecified behaviour.
 
 @node starpu_worker_get_memory_node
 @subsection @code{starpu_worker_get_memory_node} -- Get the memory node of a worker
-@deftypefun unsigned starpu_worker_get_memory_node(unsigned @var{workerid});
+@deftypefun unsigned starpu_worker_get_memory_node (unsigned @var{workerid})
 This function returns the identifier of the memory node associated to the
 worker identified by @code{workerid}.
 @end deftypefun
@@ -2790,7 +2790,7 @@ design their own data interfaces if required.
 
 @node starpu_malloc
 @subsection @code{starpu_malloc} -- Allocate data and pin it
-@deftypefun int starpu_malloc(void **@var{A}, size_t @var{dim});
+@deftypefun int starpu_malloc (void **@var{A}, size_t @var{dim})
 This function allocates data of the given size. It will also try to pin it in
 CUDA or OpenGL, so that data transfers from this buffer can be asynchronous, and
 thus permit data transfer and computation overlapping. The allocated buffer must
@@ -2860,7 +2860,7 @@ the data that is accessible from the current processing unit.
 
 @node starpu_data_register
 @subsection @code{starpu_data_register} -- Register a piece of data to StarPU
-@deftypefun void starpu_data_register(starpu_data_handle *@var{handleptr}, uint32_t @var{home_node}, void *@var{interface}, struct starpu_data_interface_ops_t *@var{ops});
+@deftypefun void starpu_data_register (starpu_data_handle *@var{handleptr}, uint32_t @var{home_node}, void *@var{interface}, {struct starpu_data_interface_ops_t} *@var{ops})
 Register a piece of data into the handle located at the @code{handleptr}
 address. The @code{interface} buffer contains the initial description of the
 data in the home node. The @code{ops} argument is a pointer to a structure
@@ -2879,7 +2879,7 @@ matrix) which can be registered by the means of helper functions (e.g.
 
 @node starpu_data_unregister
 @subsection @code{starpu_data_unregister} -- Unregister a piece of data from StarPU
-@deftypefun void starpu_data_unregister(starpu_data_handle @var{handle});
+@deftypefun void starpu_data_unregister (starpu_data_handle @var{handle})
 This function unregisters a data handle from StarPU. If the data was
 automatically allocated by StarPU because the home node was -1, all
 automatically allocated buffers are freed. Otherwise, a valid copy of the data
@@ -2890,7 +2890,7 @@ undefined behaviour.
 
 @node starpu_data_invalidate
 @subsection @code{starpu_data_invalidate} -- Invalidate all data replicates
-@deftypefun void starpu_data_invalidate(starpu_data_handle @var{handle});
+@deftypefun void starpu_data_invalidate (starpu_data_handle @var{handle})
 Destroy all replicates of the data handle. After data invalidation, the first
 access to the handle must be performed in write-only mode. Accessing an
 invalidated data in read-mode results in undefined behaviour.
@@ -2900,7 +2900,7 @@ invalidated data in read-mode results in undefined behaviour.
 
 @node starpu_data_acquire
 @subsection @code{starpu_data_acquire} -- Access registered data from the application
-@deftypefun int starpu_data_acquire(starpu_data_handle @var{handle}, starpu_access_mode @var{mode});
+@deftypefun int starpu_data_acquire (starpu_data_handle @var{handle}, starpu_access_mode @var{mode})
 The application must call this function prior to accessing registered data from
 main memory outside tasks. StarPU ensures that the application will get an
 up-to-date copy of the data in main memory located where the data was
@@ -2920,7 +2920,7 @@ tasks or from their callbacks (in that case, @code{starpu_data_acquire} returns
 
 @node starpu_data_acquire_cb
 @subsection @code{starpu_data_acquire_cb} -- Access registered data from the application asynchronously
-@deftypefun int starpu_data_acquire_cb(starpu_data_handle @var{handle}, starpu_access_mode @var{mode}, void (*@var{callback})(void *), void *@var{arg});
+@deftypefun int starpu_data_acquire_cb (starpu_data_handle @var{handle}, starpu_access_mode @var{mode}, void (*@var{callback})(void *), void *@var{arg})
 @code{starpu_data_acquire_cb} is the asynchronous equivalent of
 @code{starpu_data_release}. When the data specified in the first argument is
 available in the appropriate access mode, the callback function is executed.
@@ -2936,14 +2936,14 @@ returns 0.
 
 @node starpu_data_release
 @subsection @code{starpu_data_release} -- Release registered data from the application
-@deftypefun void starpu_data_release(starpu_data_handle @var{handle});
+@deftypefun void starpu_data_release (starpu_data_handle @var{handle})
 This function releases the piece of data acquired by the application either by
 @code{starpu_data_acquire} or by @code{starpu_data_acquire_cb}.
 @end deftypefun
 
 @node starpu_data_set_wt_mask
 @subsection @code{starpu_data_set_wt_mask} -- Set the Write-Through mask
-@deftypefun void starpu_data_set_wt_mask(starpu_data_handle @var{handle}, uint32_t @var{wt_mask});
+@deftypefun void starpu_data_set_wt_mask (starpu_data_handle @var{handle}, uint32_t @var{wt_mask})
 This function sets the write-through mask of a given data, i.e. a bitmask of
 nodes where the data should be always replicated after modification.
 @end deftypefun
@@ -2951,7 +2951,7 @@ nodes where the data should be always replicated after modification.
 @node starpu_data_prefetch_on_node
 @subsection @code{starpu_data_prefetch_on_node} -- Prefetch data to a given node
 
-@deftypefun int starpu_data_prefetch_on_node(starpu_data_handle @var{handle}, unsigned @var{node}, unsigned @var{async})
+@deftypefun int starpu_data_prefetch_on_node (starpu_data_handle @var{handle}, unsigned @var{node}, unsigned @var{async})
 Issue a prefetch request for a given data to a given node, i.e.
 requests that the data be replicated to the given node, so that it is available
 there for tasks. If the @code{async} parameter is 0, the call will block until
@@ -3075,7 +3075,7 @@ starpu_block_data_register(&block_handle, 0, (uintptr_t)block,
 @node BCSR Interface for Sparse Matrices (Blocked Compressed Sparse Row Representation)
 @subsection BCSR Interface for Sparse Matrices (Blocked Compressed Sparse Row Representation)
 
-@deftypefun void starpu_bcsr_data_register(starpu_data_handle *@var{handle}, uint32_t @var{home_node}, uint32_t @var{nnz}, uint32_t @var{nrow}, uintptr_t @var{nzval}, uint32_t *@var{colind}, uint32_t *@var{rowptr}, uint32_t @var{firstentry}, uint32_t @var{r}, uint32_t @var{c}, size_t @var{elemsize});
+@deftypefun void starpu_bcsr_data_register (starpu_data_handle *@var{handle}, uint32_t @var{home_node}, uint32_t @var{nnz}, uint32_t @var{nrow}, uintptr_t @var{nzval}, uint32_t *@var{colind}, uint32_t *@var{rowptr}, uint32_t @var{firstentry}, uint32_t @var{r}, uint32_t @var{c}, size_t @var{elemsize})
 This variant of @code{starpu_data_register} uses the BCSR sparse matrix interface.
 TODO
 @end deftypefun
@@ -3083,7 +3083,7 @@ TODO
 @node CSR Interface for Sparse Matrices (Compressed Sparse Row Representation)
 @subsection CSR Interface for Sparse Matrices (Compressed Sparse Row Representation)
 
-@deftypefun void starpu_csr_data_register(starpu_data_handle *@var{handle}, uint32_t @var{home_node}, uint32_t @var{nnz}, uint32_t @var{nrow}, uintptr_t @var{nzval}, uint32_t *@var{colind}, uint32_t *@var{rowptr}, uint32_t @var{firstentry}, size_t @var{elemsize});
+@deftypefun void starpu_csr_data_register (starpu_data_handle *@var{handle}, uint32_t @var{home_node}, uint32_t @var{nnz}, uint32_t @var{nrow}, uintptr_t @var{nzval}, uint32_t *@var{colind}, uint32_t *@var{rowptr}, uint32_t @var{firstentry}, size_t @var{elemsize})
 This variant of @code{starpu_data_register} uses the CSR sparse matrix interface.
 TODO
 @end deftypefun
@@ -3225,38 +3225,38 @@ list can be found in @code{starpu_data_filters.h} .
 @node Partitioning BCSR Data
 @subsubsection Partitioning BCSR Data
 
-@deftypefun void starpu_canonical_block_filter_bcsr(void *@var{father_interface}, void *@var{child_interface}, struct starpu_data_filter *@var{f}, unsigned @var{id}, unsigned @var{nparts});
+@deftypefun void starpu_canonical_block_filter_bcsr (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 TODO
 @end deftypefun
 
-@deftypefun void starpu_vertical_block_filter_func_csr(void *@var{father_interface}, void *@var{child_interface}, struct starpu_data_filter *@var{f}, unsigned @var{id}, unsigned @var{nparts});
+@deftypefun void starpu_vertical_block_filter_func_csr (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 TODO
 @end deftypefun
 
 @node Partitioning BLAS interface
 @subsubsection Partitioning BLAS interface
 
-@deftypefun void starpu_block_filter_func(void *@var{father_interface}, void *@var{child_interface}, struct starpu_data_filter *@var{f}, unsigned @var{id}, unsigned @var{nparts});
+@deftypefun void starpu_block_filter_func (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 This partitions a dense Matrix into horizontal blocks.
 @end deftypefun
 
-@deftypefun void starpu_vertical_block_filter_func(void *@var{father_interface}, void *@var{child_interface}, struct starpu_data_filter *@var{f}, unsigned @var{id}, unsigned @var{nparts});
+@deftypefun void starpu_vertical_block_filter_func (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 This partitions a dense Matrix into vertical blocks.
 @end deftypefun
 
 @node Partitioning Vector Data
 @subsubsection Partitioning Vector Data
 
-@deftypefun void starpu_block_filter_func_vector(void *@var{father_interface}, void *@var{child_interface}, struct starpu_data_filter *@var{f}, unsigned @var{id}, unsigned @var{nparts});
+@deftypefun void starpu_block_filter_func_vector (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 This partitions a vector into blocks of the same size.
 @end deftypefun
 
 
-@deftypefun void starpu_vector_list_filter_func(void *@var{father_interface}, void *@var{child_interface}, struct starpu_data_filter *@var{f}, unsigned @var{id}, unsigned @var{nparts});
+@deftypefun void starpu_vector_list_filter_func (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 This partitions a vector into blocks of sizes given in @code{filter_arg_ptr}.
 @end deftypefun
 
-@deftypefun void starpu_vector_divide_in_2_filter_func(void *@var{father_interface}, void *@var{child_interface}, struct starpu_data_filter *@var{f}, unsigned @var{id}, unsigned @var{nparts});
+@deftypefun void starpu_vector_divide_in_2_filter_func (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 This partitions a vector into two blocks, the first block size being given in @code{filter_arg}.
 @end deftypefun
 
@@ -3264,7 +3264,7 @@ This partitions a vector into two blocks, the first block size being given in @c
 @node Partitioning Block Data
 @subsubsection Partitioning Block Data
 
-@deftypefun void starpu_block_filter_func_block(void *@var{father_interface}, void *@var{child_interface}, struct starpu_data_filter *@var{f}, unsigned @var{id}, unsigned @var{nparts});
+@deftypefun void starpu_block_filter_func_block (void *@var{father_interface}, void *@var{child_interface}, {struct starpu_data_filter} *@var{f}, unsigned @var{id}, unsigned @var{nparts})
 This partitions a 3D matrix along the X axis.
 @end deftypefun
 
@@ -3447,7 +3447,7 @@ strategy used performance models.
 @end table
 @end deftp
 
-@deftypefun void starpu_task_init (struct starpu_task *@var{task})
+@deftypefun void starpu_task_init ({struct starpu_task} *@var{task})
 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
@@ -3463,13 +3463,13 @@ by the task are freed by calling
 @code{starpu_task_destroy}.
 @end deftypefun
 
-@deftypefun void starpu_task_deinit (struct starpu_task *@var{task})
+@deftypefun void starpu_task_deinit ({struct starpu_task} *@var{task})
 Release all the structures automatically allocated to execute @var{task}. This is
 called automatically by @code{starpu_task_destroy}, but the task structure itself is not
 freed. This should be used for statically allocated tasks for instance.
 @end deftypefun
 
-@deftypefun void starpu_task_destroy (struct starpu_task *@var{task})
+@deftypefun void starpu_task_destroy ({struct starpu_task} *@var{task})
 Free the resource allocated during @code{starpu_task_create} and
 associated with @var{task}. This function can be called automatically
 after the execution of a task by setting the @code{destroy} flag of the
@@ -3477,7 +3477,7 @@ after the execution of a task by setting the @code{destroy} flag of the
 on a statically allocated task results in an undefined behaviour.
 @end deftypefun
 
-@deftypefun int starpu_task_wait (struct starpu_task *@var{task})
+@deftypefun int starpu_task_wait ({struct starpu_task} *@var{task})
 This function blocks until @var{task} has been executed. It is not possible to
 synchronize with a task more than once. It is not possible to wait for
 synchronous or detached tasks.
@@ -3486,7 +3486,7 @@ Upon successful completion, this function returns 0. Otherwise, @code{-EINVAL}
 indicates that the specified task was either synchronous or detached.
 @end deftypefun
 
-@deftypefun int starpu_task_submit (struct starpu_task *@var{task})
+@deftypefun int starpu_task_submit ({struct starpu_task} *@var{task})
 This function submits @var{task} to StarPU. Calling this function does
 not mean that the task will be executed immediately as there can be data or task
 (tag) dependencies that are not fulfilled yet: StarPU will take care of
@@ -3512,7 +3512,7 @@ NULL if it is called either from a thread that is not a task or simply
 because there is no task being executed at the moment.
 @end deftypefun
 
-@deftypefun void starpu_display_codelet_stats (struct starpu_codelet_t *@var{cl})
+@deftypefun void starpu_display_codelet_stats ({struct starpu_codelet_t} *@var{cl})
 Output on @code{stderr} some statistics on the codelet @var{cl}.
 @end deftypefun
 
@@ -3535,7 +3535,7 @@ Output on @code{stderr} some statistics on the codelet @var{cl}.
 
 @node starpu_task_declare_deps_array
 @subsection @code{starpu_task_declare_deps_array} -- Declare task dependencies
-@deftypefun void starpu_task_declare_deps_array(struct starpu_task *@var{task}, unsigned @var{ndeps}, struct starpu_task *@var{task_array[]});
+@deftypefun void starpu_task_declare_deps_array ({struct starpu_task} *@var{task}, unsigned @var{ndeps}, {struct starpu_task} *@var{task_array[]})
 Declare task dependencies between a @code{task} and an array of tasks of length
 @code{ndeps}. This function must be called prior to the submission of the task,
 but it may called after the submission or the execution of the tasks in the
@@ -3620,7 +3620,7 @@ starpu_tag_declare_deps_array((starpu_tag_t)0x1, 2, tag_array);
 
 @node starpu_tag_wait
 @subsection @code{starpu_tag_wait} -- Block until a Tag is terminated
-@deftypefun void starpu_tag_wait(starpu_tag_t @var{id});
+@deftypefun void starpu_tag_wait (starpu_tag_t @var{id})
 This function blocks until the task associated to tag @code{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
@@ -3633,7 +3633,7 @@ data structure was freed (e.g. if the @code{destroy} flag of the
 
 @node starpu_tag_wait_array
 @subsection @code{starpu_tag_wait_array} -- Block until a set of Tags is terminated
-@deftypefun void starpu_tag_wait_array(unsigned @var{ntags}, starpu_tag_t *@var{id});
+@deftypefun void 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 @code{ntags} tags contained in the @code{id} array are
 terminated.
@@ -3641,7 +3641,7 @@ terminated.
 
 @node starpu_tag_remove
 @subsection @code{starpu_tag_remove} -- Destroy a Tag
-@deftypefun void starpu_tag_remove(starpu_tag_t @var{id});
+@deftypefun void starpu_tag_remove (starpu_tag_t @var{id})
 This function releases the resources associated to tag @code{id}. It can be
 called once the corresponding task has been executed and when there is
 no other tag that depend on this tag anymore.
@@ -3649,7 +3649,7 @@ no other tag that depend on this tag anymore.
 
 @node starpu_tag_notify_from_apps
 @subsection @code{starpu_tag_notify_from_apps} -- Feed a Tag explicitly
-@deftypefun void starpu_tag_notify_from_apps(starpu_tag_t @var{id});
+@deftypefun void starpu_tag_notify_from_apps (starpu_tag_t @var{id})
 This function explicitly unlocks tag @code{id}. It may be useful in the
 case of applications which execute part of their computation outside StarPU
 tasks (e.g. third-party libraries).  It is also provided as a
@@ -3677,7 +3677,7 @@ are also inserted in the case of data accesses from the application.
 
 @node starpu_data_set_default_sequential_consistency_flag
 @subsection @code{starpu_data_set_default_sequential_consistency_flag} -- Set default sequential consistency flag
-@deftypefun void starpu_data_set_default_sequential_consistency_flag(unsigned @var{flag});
+@deftypefun void starpu_data_set_default_sequential_consistency_flag (unsigned @var{flag})
 Set the default sequential consistency flag. If a non-zero value is passed, a
 sequential data consistency will be enforced for all handles registered after
 this function call, otherwise it is disabled. By default, StarPU enables
@@ -3688,13 +3688,13 @@ mode of a specific data handle with the
 
 @node starpu_data_get_default_sequential_consistency_flag
 @subsection @code{starpu_data_get_default_sequential_consistency_flag} -- Get current default sequential consistency flag
-@deftypefun unsigned starpu_data_set_default_sequential_consistency_flag(void);
+@deftypefun unsigned starpu_data_set_default_sequential_consistency_flag (void)
 This function returns the current default sequential consistency flag.
 @end deftypefun
 
 @node starpu_data_set_sequential_consistency_flag
 @subsection @code{starpu_data_set_sequential_consistency_flag} -- Set data sequential consistency mode
-@deftypefun void starpu_data_set_sequential_consistency_flag(starpu_data_handle @var{handle}, unsigned @var{flag});
+@deftypefun void starpu_data_set_sequential_consistency_flag (starpu_data_handle @var{handle}, unsigned @var{flag})
 Select 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
 be set with @code{starpu_data_set_sequential_consistency_flag}.
@@ -3712,25 +3712,25 @@ be set with @code{starpu_data_set_sequential_consistency_flag}.
 
 @node starpu_load_history_debug
 @subsection @code{starpu_load_history_debug}
-@deftypefun int starpu_load_history_debug(const char *@var{symbol}, struct starpu_perfmodel_t *@var{model});
+@deftypefun int starpu_load_history_debug ({const char} *@var{symbol}, {struct starpu_perfmodel_t} *@var{model})
 TODO
 @end deftypefun
 
 @node starpu_perfmodel_debugfilepath
 @subsection @code{starpu_perfmodel_debugfilepath}
-@deftypefun void starpu_perfmodel_debugfilepath(struct starpu_perfmodel_t *@var{model}, enum starpu_perf_archtype @var{arch}, char *@var{path}, size_t @var{maxlen});
+@deftypefun void starpu_perfmodel_debugfilepath ({struct starpu_perfmodel_t} *@var{model}, {enum starpu_perf_archtype} @var{arch}, char *@var{path}, size_t @var{maxlen})
 TODO
 @end deftypefun
 
 @node starpu_perfmodel_get_arch_name
 @subsection @code{starpu_perfmodel_get_arch_name}
-@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})
 TODO
 @end deftypefun
 
 @node starpu_force_bus_sampling
 @subsection @code{starpu_force_bus_sampling}
-@deftypefun void starpu_force_bus_sampling(void);
+@deftypefun void starpu_force_bus_sampling (void)
 This forces sampling the bus performance model again.
 @end deftypefun
 
@@ -3775,7 +3775,7 @@ returned.
 
 @node starpu_profiling_status_get
 @subsection @code{starpu_profiling_status_get} -- Get current profiling status
-@deftypefun int starpu_profiling_status_get(void);
+@deftypefun int starpu_profiling_status_get (void)
 Return the current profiling status or a negative value in case there was an error.
 @end deftypefun
 
@@ -3855,49 +3855,49 @@ TODO
 
 @node starpu_bus_get_count
 @subsection @code{starpu_bus_get_count}
-@deftypefun int starpu_bus_get_count(void);
+@deftypefun int starpu_bus_get_count (void)
 TODO
 @end deftypefun
 
 @node starpu_bus_get_id
 @subsection @code{starpu_bus_get_id}
-@deftypefun int starpu_bus_get_id(int @var{src}, int @var{dst});
+@deftypefun int starpu_bus_get_id (int @var{src}, int @var{dst})
 TODO
 @end deftypefun
 
 @node starpu_bus_get_src
 @subsection @code{starpu_bus_get_src}
-@deftypefun int starpu_bus_get_src(int @var{busid});
+@deftypefun int starpu_bus_get_src (int @var{busid})
 TODO
 @end deftypefun
 
 @node starpu_bus_get_dst
 @subsection @code{starpu_bus_get_dst}
-@deftypefun int starpu_bus_get_dst(int @var{busid});
+@deftypefun int starpu_bus_get_dst (int @var{busid})
 TODO
 @end deftypefun
 
 @node starpu_timing_timespec_delay_us
 @subsection @code{starpu_timing_timespec_delay_us}
-@deftypefun double starpu_timing_timespec_delay_us(struct timespec *@var{start}, struct timespec *@var{end});
+@deftypefun double starpu_timing_timespec_delay_us ({struct timespec} *@var{start}, {struct timespec} *@var{end})
 TODO
 @end deftypefun
 
 @node starpu_timing_timespec_to_us
 @subsection @code{starpu_timing_timespec_to_us}
-@deftypefun double starpu_timing_timespec_to_us(struct timespec *@var{ts});
+@deftypefun double starpu_timing_timespec_to_us ({struct timespec} *@var{ts})
 TODO
 @end deftypefun
 
 @node starpu_bus_profiling_helper_display_summary
 @subsection @code{starpu_bus_profiling_helper_display_summary}
-@deftypefun void starpu_bus_profiling_helper_display_summary(void);
+@deftypefun void starpu_bus_profiling_helper_display_summary (void)
 TODO
 @end deftypefun
 
 @node starpu_worker_profiling_helper_display_summary
 @subsection @code{starpu_worker_profiling_helper_display_summary}
-@deftypefun void starpu_worker_profiling_helper_display_summary(void);
+@deftypefun void starpu_worker_profiling_helper_display_summary (void)
 TODO
 @end deftypefun
 
@@ -3916,7 +3916,7 @@ TODO
 
 @node starpu_cuda_get_local_stream
 @subsection @code{starpu_cuda_get_local_stream} -- Get current worker's CUDA stream
-@deftypefun {cudaStream_t *} starpu_cuda_get_local_stream(void);
+@deftypefun {cudaStream_t *} starpu_cuda_get_local_stream (void)
 StarPU provides a stream for every CUDA device controlled by StarPU. This
 function is only provided for convenience so that programmers can easily use
 asynchronous operations within codelets without having to create a stream by
@@ -3928,7 +3928,7 @@ the likelihood of having all transfers overlapped.
 
 @node starpu_helper_cublas_init
 @subsection @code{starpu_helper_cublas_init} -- Initialize CUBLAS on every CUDA device
-@deftypefun void starpu_helper_cublas_init(void);
+@deftypefun void starpu_helper_cublas_init (void)
 The CUBLAS library must be initialized prior to any CUBLAS call. Calling
 @code{starpu_helper_cublas_init} will initialize CUBLAS on every CUDA device
 controlled by StarPU. This call blocks until CUBLAS has been properly
@@ -3937,7 +3937,7 @@ initialized on every device.
 
 @node starpu_helper_cublas_shutdown
 @subsection @code{starpu_helper_cublas_shutdown} -- Deinitialize CUBLAS on every CUDA device
-@deftypefun void starpu_helper_cublas_shutdown(void);
+@deftypefun void starpu_helper_cublas_shutdown (void)
 This function synchronously deinitializes the CUBLAS library on every CUDA device.
 @end deftypefun
 
@@ -3997,19 +3997,19 @@ relocation purpose for instance).
 
 @node starpu_opencl_load_opencl_from_file
 @subsubsection @code{starpu_opencl_load_opencl_from_file} -- Compiling OpenCL source code
-@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 (char *@var{source_file_name}, {struct starpu_opencl_program} *@var{opencl_programs}, {const char}* @var{build_options})
 TODO
 @end deftypefun
 
 @node starpu_opencl_load_opencl_from_string
 @subsubsection @code{starpu_opencl_load_opencl_from_string} -- Compiling OpenCL source code
-@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 (char *@var{opencl_program_source}, {struct starpu_opencl_program} *@var{opencl_programs}, {const char}* @var{build_options})
 TODO
 @end deftypefun
 
 @node starpu_opencl_unload_opencl
 @subsubsection @code{starpu_opencl_unload_opencl} -- Releasing OpenCL code
-@deftypefun int starpu_opencl_unload_opencl(struct starpu_opencl_program *@var{opencl_programs});
+@deftypefun int starpu_opencl_unload_opencl ({struct starpu_opencl_program} *@var{opencl_programs})
 TODO
 @end deftypefun
 
@@ -4023,13 +4023,13 @@ TODO
 
 @node starpu_opencl_load_kernel
 @subsubsection @code{starpu_opencl_load_kernel} -- Loading a kernel
-@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}, char *@var{kernel_name}, int @var{devid})
 TODO
 @end deftypefun
 
 @node starpu_opencl_relase_kernel
 @subsubsection @code{starpu_opencl_release_kernel} -- Releasing a kernel
-@deftypefun int starpu_opencl_release_kernel(cl_kernel @var{kernel});
+@deftypefun int starpu_opencl_release_kernel (cl_kernel @var{kernel})
 TODO
 @end deftypefun
 
@@ -4042,7 +4042,7 @@ TODO
 
 @node starpu_opencl_collect_stats
 @subsubsection @code{starpu_opencl_collect_stats} -- Collect statistics on a kernel execution
-@deftypefun int starpu_opencl_collect_stats(cl_event @var{event});
+@deftypefun int starpu_opencl_collect_stats (cl_event @var{event})
 After termination of the kernels, the OpenCL codelet should call this function
 to pass it the even returned by @code{clEnqueueNDRangeKernel}, to let StarPU
 collect statistics about the kernel execution (used cycles, consumed power).
@@ -4064,7 +4064,7 @@ nothing yet.
 
 @node starpu_data_cpy
 @subsection @code{starpu_data_cpy} -- Copy a data handle into another data handle
-@deftypefun int starpu_data_cpy(starpu_data_handle @var{dst_handle}, starpu_data_handle @var{src_handle}, int @var{asynchronous}, void (*@var{callback_func})(void*), void *@var{callback_arg});
+@deftypefun int starpu_data_cpy (starpu_data_handle @var{dst_handle}, starpu_data_handle @var{src_handle}, int @var{asynchronous}, void (*@var{callback_func})(void*), void *@var{callback_arg})
 Copy the content of the @code{src_handle} into the @code{dst_handle} handle.
 The @code{asynchronous} parameter indicates whether the function should 
 block or not. In the case of an asynchronous call, it is possible to
@@ -4079,7 +4079,7 @@ given the @code{callback_arg} pointer as argument.
 
 @node starpu_execute_on_each_worker
 @subsection @code{starpu_execute_on_each_worker} -- Execute a function on a subset of workers
-@deftypefun void starpu_execute_on_each_worker(void (*@var{func})(void *), void *@var{arg}, uint32_t @var{where});
+@deftypefun void starpu_execute_on_each_worker (void (*@var{func})(void *), void *@var{arg}, uint32_t @var{where})
 When calling this method, the offloaded function specified by the first argument is
 executed by every StarPU worker that may execute the function.
 The second argument is passed to the offloaded function.
@@ -4200,7 +4200,7 @@ Description of the policy (optionnal).
 
 @node starpu_worker_set_sched_condition
 @subsection @code{starpu_worker_set_sched_condition} -- Specify the condition variable associated to a worker
-@deftypefun void starpu_worker_set_sched_condition(int @var{workerid}, pthread_cond_t *@var{sched_cond}, pthread_mutex_t *@var{sched_mutex});
+@deftypefun void starpu_worker_set_sched_condition (int @var{workerid}, pthread_cond_t *@var{sched_cond}, pthread_mutex_t *@var{sched_mutex})
 When there is no available task for a worker, StarPU blocks this worker on a
 condition variable. This function specifies which condition variable (and the
 associated mutex) should be used to block (and to wake up) a worker. Note that
@@ -4213,7 +4213,7 @@ call this function once per worker.
 
 @node starpu_sched_set_min_priority
 @subsection @code{starpu_sched_set_min_priority}
-@deftypefun void starpu_sched_set_min_priority(int @var{min_prio});
+@deftypefun void starpu_sched_set_min_priority (int @var{min_prio})
 Defines the minimum priority level supported by the scheduling policy. The
 default minimum priority level is the same as the default priority level which
 is 0 by convention.  The application may access that value by calling the
@@ -4224,7 +4224,7 @@ be used directly from the application.
 
 @node starpu_sched_set_max_priority
 @subsection @code{starpu_sched_set_max_priority}
-@deftypefun void starpu_sched_set_min_priority(int @var{max_prio});
+@deftypefun void starpu_sched_set_min_priority (int @var{max_prio})
 Defines the maximum priority level supported by the scheduling policy. The
 default maximum priority level is 1.  The application may access that value by
 calling the @code{starpu_sched_get_max_priority} function. This function should
@@ -4234,7 +4234,7 @@ should not be used directly from the application.
 
 @node starpu_push_local_task
 @subsection @code{starpu_push_local_task}
-@deftypefun int starpu_push_local_task(int @var{workerid}, struct starpu_task *@var{task}, int @var{back});
+@deftypefun int starpu_push_local_task (int @var{workerid}, {struct starpu_task} *@var{task}, int @var{back})
 The scheduling policy may put tasks directly into a worker's local queue so
 that it is not always necessary to create its own queue when the local queue
 is sufficient. If "back" not null, the task is put at the back of the queue