doc/doxygen/chapters/api: fix documentation to be uptodate with code

doc/doxygen/chapters/api/data_management.doxy

@@ -250,18 +250,18 @@ Similarly to starpu_data_acquire_cb(), this function is
 non-blocking and may be called from task callbacks. Upon successful
 completion, this function returns 0.
 
-\fn int starpu_data_acquire_on_node(starpu_data_handle_t handle, unsigned node, enum starpu_data_access_mode mode)
+\fn int starpu_data_acquire_on_node(starpu_data_handle_t handle, int node, enum starpu_data_access_mode mode)
 \ingroup API_Data_Management
 This is the same as starpu_data_acquire(), except that the data
 will be available on the given memory node instead of main memory.
 
-\fn int starpu_data_acquire_on_node_cb(starpu_data_handle_t handle, unsigned node, enum starpu_data_access_mode mode, void (*callback)(void *), void *arg)
+\fn int starpu_data_acquire_on_node_cb(starpu_data_handle_t handle, int node, enum starpu_data_access_mode mode, void (*callback)(void *), void *arg)
 \ingroup API_Data_Management
 This is the same as starpu_data_acquire_cb(), except that the
 data will be available on the given memory node instead of main
 memory.
 
-\fn int starpu_data_acquire_on_node_cb_sequential_consistency(starpu_data_handle_t handle, unsigned node, enum starpu_data_access_mode mode, void (*callback)(void *), void *arg, int sequential_consistency)
+\fn int starpu_data_acquire_on_node_cb_sequential_consistency(starpu_data_handle_t handle, int node, enum starpu_data_access_mode mode, void (*callback)(void *), void *arg, int sequential_consistency)
 \ingroup API_Data_Management
 This is the same as starpu_data_acquire_cb_sequential_consistency(), except that the
 data will be available on the given memory node instead of main
@@ -282,7 +282,7 @@ This function releases the piece of data acquired by the
 application either by starpu_data_acquire() or by
 starpu_data_acquire_cb().
 
-\fn void starpu_data_release_on_node(starpu_data_handle_t handle, unsigned node)
+\fn void starpu_data_release_on_node(starpu_data_handle_t handle, int node)
 \ingroup API_Data_Management
 This is the same as starpu_data_release(), except that the data
 will be available on the given memory \p node instead of main memory.

doc/doxygen/chapters/api/modularized_scheduler.doxy

@@ -72,7 +72,7 @@ The actual scheduler
 \var starpu_sched_tree::sched_ctx_id
 	the context id of the scheduler
 
-\fn struct starpu_sched_component * starpu_sched_component_create(void)
+\fn struct starpu_sched_component *starpu_sched_component_create(void)
 \ingroup API_Modularized_Scheduler
 	 allocate and initialize component field with defaults values :
 	.pop_task make recursive call on father
@@ -84,72 +84,72 @@ The actual scheduler
 	.deinit_data does nothing
 
 
-\fn void starpu_sched_component_destroy(struct starpu_sched_component * component)
+\fn void starpu_sched_component_destroy(struct starpu_sched_component *component)
 \ingroup API_Modularized_Scheduler
 	 free data allocated by starpu_sched_component_create and call component->deinit_data(component)
 	 set to null the member starpu_sched_component::fathers[sched_ctx_id] of all child if its equal to \p component
 
-\fn void starpu_sched_component_set_father(struct starpu_sched_component * component, struct starpu_sched_component * father_component, unsigned sched_ctx_id)
+\fn void starpu_sched_component_set_father(struct starpu_sched_component *component, struct starpu_sched_component *father_component, unsigned sched_ctx_id)
 \ingroup API_Modularized_Scheduler
 	 set component->fathers[sched_ctx_id] to father_component
 
-\fn void starpu_sched_component_add_child(struct starpu_sched_component* component, struct starpu_sched_component * child)
+\fn void starpu_sched_component_add_child(struct starpu_sched_component *component, struct starpu_sched_component *child)
 \ingroup API_Modularized_Scheduler
 	 add child to component->children and increment nchildren as well.
 	 and do not modify child->fathers
 	 \p child must not be already in starpu_sched_component::children of \p component
 
-\fn void starpu_sched_component_remove_child(struct starpu_sched_component * component, struct starpu_sched_component * child)
+\fn void starpu_sched_component_remove_child(struct starpu_sched_component *component, struct starpu_sched_component *child)
 \ingroup API_Modularized_Scheduler
 	 remove child from component->children and decrements nchildren
 	 \p child must be in starpu_sched_component::child of \p component
 
 
-\fn int starpu_sched_component_can_execute_task(struct starpu_sched_component * component, struct starpu_task * task)
+\fn int starpu_sched_component_can_execute_task(struct starpu_sched_component *component, struct starpu_task *task)
 \ingroup API_Modularized_Scheduler
 	 return true iff \p component can execute \p task, this function take into account the workers available in the scheduling context
 
-\fn int STARPU_WARN_UNUSED_RESULT starpu_sched_component_execute_preds(struct starpu_sched_component * component, struct starpu_task * task, double * length);
+\fn int STARPU_WARN_UNUSED_RESULT starpu_sched_component_execute_preds(struct starpu_sched_component *component, struct starpu_task *task, double *length);
 \ingroup API_Modularized_Scheduler
 	 return a non null value if \p component can execute \p task.
 	 write the execution prediction length for the best implementation of the best worker available and write this at \p length address.
 	 this result is more relevant if starpu_sched_component::is_homogeneous is non null.
 	 if a worker need to be calibrated for an implementation, nan is set to \p length.
 
-\fn double starpu_sched_component_transfer_length(struct starpu_sched_component * component, struct starpu_task * task);
+\fn double starpu_sched_component_transfer_length(struct starpu_sched_component *component, struct starpu_task *task);
 \ingroup API_Modularized_Scheduler
 	 return the average time to transfer \p task data to underlying \p component workers.
 
-\fn struct starpu_sched_component * starpu_sched_component_worker_get(int workerid)
+\fn struct starpu_sched_component *starpu_sched_component_worker_get(int workerid)
 \ingroup API_Modularized_Scheduler
 	 return the struct starpu_sched_component corresponding to \p workerid. Undefined if \p workerid is not a valid workerid
 
 
-\fn int starpu_sched_component_is_worker(struct starpu_sched_component * component)
+\fn int starpu_sched_component_is_worker(struct starpu_sched_component *component)
 \ingroup API_Modularized_Scheduler
 	 return true iff \p component is a worker component
-\fn int starpu_sched_component_is_simple_worker(struct starpu_sched_component * component)
+\fn int starpu_sched_component_is_simple_worker(struct starpu_sched_component *component)
 \ingroup API_Modularized_Scheduler
 	 return true iff \p component is a simple worker component
-\fn int starpu_sched_component_is_combined_worker(struct starpu_sched_component * component)
+\fn int starpu_sched_component_is_combined_worker(struct starpu_sched_component *component)
 \ingroup API_Modularized_Scheduler
 	 return true iff \p component is a combined worker component
-\fn int starpu_sched_component_worker_get_workerid(struct starpu_sched_component * worker_component)
+\fn int starpu_sched_component_worker_get_workerid(struct starpu_sched_component *worker_component)
 \ingroup API_Modularized_Scheduler
 	 return the workerid of \p worker_component, undefined if starpu_sched_component_is_worker(worker_component) == 0
 
 
-\fn struct starpu_sched_component * starpu_sched_component_fifo_create(void * arg STARPU_ATTRIBUTE_UNUSED)
+\fn struct starpu_sched_component *starpu_sched_component_fifo_create(void *arg STARPU_ATTRIBUTE_UNUSED)
 \ingroup API_Modularized_Scheduler
 	 Return a struct starpu_sched_component with a fifo. A stable sort is performed according to tasks priorities.
 	 A push_task call on this component does not perform recursive calls, underlying components will have to call pop_task to get it.
 	 starpu_sched_component::estimated_end function compute the estimated length by dividing the sequential length by the number of underlying workers. Do not take into account tasks that are currently executed.
 
-\fn int starpu_sched_component_is_fifo(struct starpu_sched_component * component)
+\fn int starpu_sched_component_is_fifo(struct starpu_sched_component *component)
 \ingroup API_Modularized_Scheduler
 	 return true iff \p component is a fifo component
 
-\fn struct starpu_sched_component * starpu_sched_component_work_stealing_create(void * arg STARPU_ATTRIBUTE_UNUSED)
+\fn struct starpu_sched_component *starpu_sched_component_work_stealing_create(void *arg STARPU_ATTRIBUTE_UNUSED)
 \ingroup API_Modularized_Scheduler
 	 return a component that perform a work stealing scheduling. Tasks are pushed in a round robin way. estimated_end return the average of expected length of fifos, starting at the average of the expected_end of his children. When a worker have to steal a task, it steal a task in a round robin way, and get the last pushed task of the higher priority.
 
@@ -158,11 +158,11 @@ The actual scheduler
 \ingroup API_Modularized_Scheduler
 	 undefined if there is no work stealing component in the scheduler. If any, \p task is pushed in a default way if the caller is the application, and in the caller's fifo if its a worker.
 
-\fn int starpu_sched_component_is_work_stealing(struct starpu_sched_component * component)
+\fn int starpu_sched_component_is_work_stealing(struct starpu_sched_component *component)
 \ingroup API_Modularized_Scheduler
 	 return true iff \p component is a work stealing component
 
-\fn struct starpu_sched_component * starpu_sched_component_random_create(void * arg STARPU_ATTRIBUTE_UNUSED)
+\fn struct starpu_sched_component *starpu_sched_component_random_create(void *arg STARPU_ATTRIBUTE_UNUSED)
 \ingroup API_Modularized_Scheduler
 	 create a component that perform a random scheduling
 
@@ -170,11 +170,11 @@ The actual scheduler
 \ingroup API_Modularized_Scheduler
 	 return true iff \p component is a random component
 
-\fn struct starpu_sched_component * starpu_sched_component_heft_create(struct starpu_heft_data * heft_data)
+\fn struct starpu_sched_component *starpu_sched_component_heft_create(struct starpu_heft_data *heft_data)
 \ingroup API_Modularized_Scheduler
 	 this component perform a heft scheduling
 
-\fn int starpu_sched_component_is_heft(struct starpu_sched_component * component)
+\fn int starpu_sched_component_is_heft(struct starpu_sched_component *component)
 \ingroup API_Modularized_Scheduler
 	 return true iff \p component is a heft component
 
@@ -199,7 +199,7 @@ starpu_sched_component_heft_create parameters
 	 argument passed to starpu_heft_data::calibrating_component_create
 
 
-\fn struct starpu_sched_component * starpu_sched_component_best_implementation_create(void * arg STARPU_ATTRIBUTE_UNUSED);
+\fn struct starpu_sched_component *starpu_sched_component_best_implementation_create(struct starpu_sched_tree *tree, void *arg STARPU_ATTRIBUTE_UNUSED)
 \ingroup API_Modularized_Scheduler
 	 Select the implementation that offer the shortest computation length for the first worker that can execute the task.
 	 Or an implementation that need to be calibrated.
@@ -208,10 +208,10 @@ starpu_sched_component_heft_create parameters
 
 
 
-\fn struct starpu_sched_tree * starpu_sched_tree_create(void)
+\fn struct starpu_sched_tree *starpu_sched_tree_create(void)
 \ingroup API_Modularized_Scheduler
 	 create a empty initialized starpu_sched_tree
-\fn void starpu_sched_tree_destroy(struct starpu_sched_tree * tree, unsigned sched_ctx_id)
+\fn void starpu_sched_tree_destroy(struct starpu_sched_tree *tree, unsigned sched_ctx_id)
 \ingroup API_Modularized_Scheduler
 	 destroy tree and free all non shared component in it.
 \fn void starpu_sched_component_destroy_rec (struct starpu_sched_component *component, unsigned sched_ctx_id)
@@ -219,14 +219,14 @@ starpu_sched_component_heft_create parameters
 	 recursively destroy non shared parts of a \p component 's tree
 
 
-\fn starpu_sched_component_available(struct starpu_sched_component * component)
+\fn starpu_sched_component_available(struct starpu_sched_component *component)
 \ingroup API_Modularized_Scheduler
 	 notify all component's underlying workers that a task is available to pop
 
-\fn int starpu_sched_tree_push_task(struct starpu_task * task)
+\fn int starpu_sched_tree_push_task(struct starpu_task *task)
 \ingroup API_Modularized_Scheduler
 	 compatibility with starpu_sched_policy interface
-\fn struct starpu_task * starpu_sched_tree_pop_task(unsigned sched_ctx_id)
+\fn struct starpu_task *starpu_sched_tree_pop_task(unsigned sched_ctx_id)
 \ingroup API_Modularized_Scheduler
 	 compatibility with starpu_sched_policy interface
 \fn void starpu_sched_tree_add_workers(unsigned sched_ctx_id, int *workerids, unsigned nworkers)
@@ -235,79 +235,79 @@ starpu_sched_component_heft_create parameters
 \fn void starpu_sched_tree_remove_workers(unsigned sched_ctx_id, int *workerids, unsigned nworkers)
 \ingroup API_Modularized_Scheduler
 	 compatibility with starpu_sched_policy interface
-\fn void starpu_sched_component_worker_pre_exec_hook(struct starpu_task * task)
+\fn void starpu_sched_component_worker_pre_exec_hook(struct starpu_task *task)
 \ingroup API_Modularized_Scheduler
 	 compatibility with starpu_sched_policy interface
 	 update predictions for workers
-\fn void starpu_sched_component_worker_post_exec_hook(struct starpu_task * task)
+\fn void starpu_sched_component_worker_post_exec_hook(struct starpu_task *task)
 \ingroup API_Modularized_Scheduler
 	 compatibility with starpu_sched_policy interface
 
 
-\fn void starpu_sched_tree_update_workers(struct starpu_sched_tree * t)
+\fn void starpu_sched_tree_update_workers(struct starpu_sched_tree *t)
 \ingroup API_Modularized_Scheduler
 	 recursively set all starpu_sched_component::workers, do not take into account shared parts (except workers).
 
-\fn void starpu_sched_tree_update_workers_in_ctx(struct starpu_sched_tree * t)
+\fn void starpu_sched_tree_update_workers_in_ctx(struct starpu_sched_tree *t)
 \ingroup API_Modularized_Scheduler
 	 recursively set all starpu_sched_component::workers_in_ctx, do not take into account shared parts (except workers)
 
 \struct starpu_bitmap;
 \ingroup API_Modularized_Scheduler
 	 implement a simple bitmap
-\fn struct starpu_bitmap * starpu_bitmap_create(void)
+\fn struct starpu_bitmap *starpu_bitmap_create(void)
 \ingroup API_Modularized_Scheduler
 	 create a empty starpu_bitmap
-\fn void starpu_bitmap_destroy(struct starpu_bitmap *)
+\fn void starpu_bitmap_destroy(struct starpu_bitmap *b)
 \ingroup API_Modularized_Scheduler
 	 free a starpu_bitmap
 
-\fn void starpu_bitmap_set(struct starpu_bitmap * bitmap, int e)
+\fn void starpu_bitmap_set(struct starpu_bitmap *b, int e)
 \ingroup API_Modularized_Scheduler
-	 set bit \p e in \p bitmap
-\fn void starpu_bitmap_unset(struct starpu_bitmap * bitmap, int e)
+	 set bit \p e in \p b
+\fn void starpu_bitmap_unset(struct starpu_bitmap *b, int e)
 \ingroup API_Modularized_Scheduler
-	 unset bit \p e in \p bitmap
+	 unset bit \p e in \p b
 
-\fn void starpu_bitmap_unset_all(struct starpu_bitmap * bitmap)
+\fn void starpu_bitmap_unset_all(struct starpu_bitmap *b)
 \ingroup API_Modularized_Scheduler
-	 unset all bits in \b bitmap
+	 unset all bits in \b b
 
-\fn int starpu_bitmap_get(struct starpu_bitmap * bitmap, int e);
+\fn int starpu_bitmap_get(struct starpu_bitmap *b, int e);
 \ingroup API_Modularized_Scheduler
-	 return true iff bit \p e is set in \p bitmap
+	 return true iff bit \p e is set in \p b
 
-\fn int starpu_bitmap_cardinal(struct starpu_bitmap * bitmap);
+\fn int starpu_bitmap_cardinal(struct starpu_bitmap *b);
 \ingroup API_Modularized_Scheduler
-	 return the number of set bits in \p bitmap
+	 return the number of set bits in \p b
 
 
-\fn int starpu_bitmap_first(struct starpu_bitmap * bitmap)
+\fn int starpu_bitmap_first(struct starpu_bitmap *b)
 \ingroup API_Modularized_Scheduler
-	 return the position of the first set bit of \p bitmap, -1 if none
-\fn int starpu_bitmap_last(struct starpu_bitmap * bitmap)
+	 return the position of the first set bit of \p b, -1 if none
+\fn int starpu_bitmap_last(struct starpu_bitmap *b)
 \ingroup API_Modularized_Scheduler
-	 return the position of the last set bit of \p bitmap, -1 if none
+	 return the position of the last set bit of \p b, -1 if none
 
-\fn int starpu_bitmap_next(struct starpu_bitmap *, int e)
+\fn int starpu_bitmap_next(struct starpu_bitmap *b, int e)
 \ingroup API_Modularized_Scheduler
-	 return the position of set bit right after \p e in \p bitmap, -1 if none
+	 return the position of set bit right after \p e in \p b, -1 if none
 
 
 \struct starpu_sched_component_composed_recipe;
 \ingroup API_Modularized_Scheduler
 	parameters for starpu_sched_component_composed_component_create
 
-\fn struct starpu_sched_component_composed_recipe * starpu_sched_component_create_recipe(void)
+\fn struct starpu_sched_component_composed_recipe *starpu_sched_component_create_recipe(void)
 \ingroup API_Modularized_Scheduler
 	 return an empty recipe for a composed component, it should not be used without modification
 
 
-\fn struct starpu_sched_component_composed_recipe * starpu_sched_component_create_recipe_singleton(struct starpu_sched_component *(*create_component)(void * arg), void * arg)
+\fn struct starpu_sched_component_composed_recipe *starpu_sched_component_create_recipe_singleton(struct starpu_sched_component *(*create_component)(void *arg), void *arg)
 \ingroup API_Modularized_Scheduler
 	 return a recipe to build a composed component with a \p create_component
 
-\fn void starpu_sched_recipe_add_component(struct starpu_sched_component_composed_recipe * recipe, struct starpu_sched_component *(*create_component)(void * arg), void * arg)
+\fn void starpu_sched_recipe_add_component(struct starpu_sched_component_composed_recipe *recipe, struct starpu_sched_component *(*create_component)(void *arg), void *arg)
 \ingroup API_Modularized_Scheduler
 	 add \p create_component under all previous components in recipe
 
@@ -315,7 +315,7 @@ starpu_sched_component_heft_create parameters
 \ingroup API_Modularized_Scheduler
 	 destroy composed_sched_component, this should be done after starpu_sched_component_composed_component_create was called
 
-\fn struct starpu_sched_component * starpu_sched_component_composed_component_create(struct starpu_sched_component_composed_recipe * recipe)
+\fn struct starpu_sched_component *starpu_sched_component_composed_component_create(struct starpu_sched_component_composed_recipe *recipe)
 \ingroup API_Modularized_Scheduler
 	 create a component that behave as all component of recipe where linked. Except that you cant use starpu_sched_component_is_foo function
 	 if recipe contain a single create_foo arg_foo pair, create_foo(arg_foo) is returned instead of a composed component
@@ -344,7 +344,7 @@ starpu_sched_component_heft_create parameters
      If this flag is not set, a new fifo will be built for each of them (if they have the same starpu_perf_arch and the same
      numa component it will be shared
 
-\fn struct starpu_sched_tree * starpu_sched_component_make_scheduler(unsigned sched_ctx_id, struct starpu_sched_specs s);
+\fn struct starpu_sched_tree *starpu_sched_component_make_scheduler(unsigned sched_ctx_id, struct starpu_sched_specs s);
 \ingroup API_Modularized_Scheduler
 	 this function build a scheduler for \p sched_ctx_id according to \p s and the hwloc topology of the machine.
 */

doc/doxygen/chapters/api/mpi.doxy

@@ -200,7 +200,7 @@ Tell StarPU-MPI which MPI tag to use when exchanging the data.
 \ingroup API_MPI_Support
 Returns the MPI tag to be used when exchanging the data.
 
-\fn int starpu_mpi_data_register(starpu_data_handle_t handle, int tag, int rank)
+\fn void starpu_mpi_data_register(starpu_data_handle_t data_handle, int tag, int rank)
 \ingroup API_MPI_Support
 Calling this function should be prefered to calling both
 starpu_data_set_rank() and starpu_data_set_tag() as it also allows to

doc/doxygen/chapters/api/opencl_extensions.doxy

@@ -1,7 +1,7 @@
 /*
  * This file is part of the StarPU Handbook.
  * Copyright (C) 2009--2011  Universit@'e de Bordeaux
- * Copyright (C) 2010, 2011, 2012, 2013  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011, 2012, 2013, 2014  Centre National de la Recherche Scientifique
  * Copyright (C) 2011, 2012 Institut National de Recherche en Informatique et Automatique
  * See the file version.doxy for copying conditions.
  */
@@ -201,7 +201,7 @@ Call the function starpu_opencl_report_error() with the given \p msg
 and the given error \p status, with the current function name, current
 file and line number.
 
-\fn cl_int starpu_opencl_allocate_memory(cl_mem *addr, size_t size, cl_mem_flags flags)
+\fn cl_int starpu_opencl_allocate_memory(int devid, cl_mem *addr, size_t size, cl_mem_flags flags)
 \ingroup API_OpenCL_Extensions
 Allocate \p size bytes of memory, stored in \p addr. \p flags must be a valid
 combination of cl_mem_flags values.

doc/doxygen/chapters/api/openmp_runtime_support.doxy

@@ -210,7 +210,7 @@ the runtime support for OpenMP.
 \ingroup API_OpenMP_Runtime_Support
 Initializes StarPU and its OpenMP Runtime support.
 
-\fn int starpu_omp_shutdown(void)
+\fn void starpu_omp_shutdown(void)
 \ingroup API_OpenMP_Runtime_Support
 Shutdown StarPU and its OpenMP Runtime support.
 
@@ -480,7 +480,7 @@ the execution of all the sections (<c>nowait==0</c>) or not (<c>nowait==!0</c>).
 
 This function can be used to implement <c>\#pragma omp sections</c> and <c>\#pragma omp section</c>.
 
-\fn void starpu_omp_sections_combined(unsigned long long nb_sections, void (*section_f)(unsigned long long section_num, void *arg), void **section_arg, int nowait)
+\fn void starpu_omp_sections_combined(unsigned long long nb_sections, void (*section_f)(unsigned long long section_num, void *arg), void *section_arg, int nowait)
 \ingroup API_OpenMP_Runtime_Support
 Alternative implementation of sections. This function differs from
 #starpu_omp_sections in that all the sections are combined within a single
@@ -952,7 +952,7 @@ This function returns the precision of the time used by \p starpu_omp_get_wtime.
 
 \sa starpu_omp_get_wtime
 
-\fn void starpu_omp_vector_annotate (starpu_data_handle_t handle, uint32_t slice_base)
+\fn void starpu_omp_vector_annotate(starpu_data_handle_t handle, uint32_t slice_base)
 \ingroup API_OpenMP_Runtime_Support
 This function enables setting additional vector metadata needed by the OpenMP Runtime Support.
 

doc/doxygen/chapters/api/performance_model.doxy

@@ -207,11 +207,7 @@ in bytes
 \var starpu_perfmodel_history_entry::flops
 Provided by the application
 
-\fn void starpu_perfmodel_init(struct starpu_perfmodel *model)
-\ingroup API_Performance_Model
-todo
-
-\fn void starpu_perfmodel_init_with_file(FILE*f, struct starpu_perfmodel *model)
+\fn void starpu_perfmodel_init(FILE *f, struct starpu_perfmodel *model)
 \ingroup API_Performance_Model
 todo