include: remove documentation as it is already defined elsewhere

include/starpu_data_filters.h

@@ -45,35 +45,25 @@ void starpu_data_unpartition(starpu_data_handle_t root_data, unsigned gathering_
 int starpu_data_get_nb_children(starpu_data_handle_t handle);
 starpu_data_handle_t starpu_data_get_child(starpu_data_handle_t handle, unsigned i);
 
-/* 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);
 
-/* struct starpu_data_filter * list */
 void starpu_data_map_filters(starpu_data_handle_t root_data, unsigned nfilters, ...);
-/* Same, but using va_list */
 void starpu_data_vmap_filters(starpu_data_handle_t root_data, unsigned nfilters, va_list pa);
 
-/* a few examples of filters */
-
-/* for BCSR */
 void starpu_bcsr_filter_canonical_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
 void starpu_csr_filter_vertical_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
 
-/* (filters for matrix interface) */
 void starpu_matrix_filter_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
 void starpu_matrix_filter_block_shadow(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
 void starpu_matrix_filter_vertical_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
 void starpu_matrix_filter_vertical_block_shadow(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
 
-/* for vector */
 void starpu_vector_filter_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
 void starpu_vector_filter_block_shadow(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
 void starpu_vector_filter_list(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
 void starpu_vector_filter_divide_in_2(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
 
-/* for block */
 void starpu_block_filter_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
 void starpu_block_filter_block_shadow(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);
 void starpu_block_filter_vertical_block(void *father_interface, void *child_interface, struct starpu_data_filter *f, unsigned id, unsigned nparts);

include/starpu_opencl.h

@@ -74,29 +74,6 @@ int starpu_opencl_release_kernel(cl_kernel kernel);
 
 int starpu_opencl_collect_stats(cl_event event);
 
-/*
- * Sets the arguments of an OpenCL kernel.
- * Arguments to pass to the kernel should be given as follows :
- *
- * 	size of the argument,  pointer to the argument
- *
- * 0 must be passed to this function after the kernel arguments.
- *
- * In case of failure, returns the id of the argument that could not be set,
- * and sets "error" to the error returned. Otherwise, returns the number of
- * arguments that were set.
- *
- * Example :
- * int n;
- * cl_int err;
- * cl_kernel kernel;
- * n = starpu_opencl_set_kernel_args(&err, 2, &kernel,
- *				     sizeof(foo), &foo,
- *                                   sizeof(bar), &bar,
- *                                   0);
- * if (n != 2)
- * 	fprintf(stderr, "Error : %d\n", err);
- */
 int starpu_opencl_set_kernel_args(cl_int *err, cl_kernel *kernel, ...);
 
 cl_int starpu_opencl_allocate_memory(cl_mem *addr, size_t size, cl_mem_flags flags);

include/starpu_profiling.h

@@ -32,28 +32,22 @@ extern "C"
 
 struct starpu_profiling_task_info
 {
-	/* Task submission */
 	struct timespec submit_time;
 
-	/* Scheduling overhead */
 	struct timespec push_start_time;
 	struct timespec push_end_time;
 	struct timespec pop_start_time;
 	struct timespec pop_end_time;
 
-	/* Take input data */
 	struct timespec acquire_data_start_time;
 	struct timespec acquire_data_end_time;
 
-	/* Execution */
 	struct timespec start_time;
 	struct timespec end_time;
 
-	/* Release data */
 	struct timespec release_data_start_time;
 	struct timespec release_data_end_time;
 
-	/* Callback */
 	struct timespec callback_start_time;
 	struct timespec callback_end_time;
 
@@ -65,7 +59,6 @@ struct starpu_profiling_task_info
 	double power_consumed;
 };
 
-/* The timing is provided since the previous call to starpu_profiling_worker_get_info */
 struct starpu_profiling_worker_info
 {
 	struct timespec start_time;
@@ -87,19 +80,10 @@ struct starpu_profiling_bus_info
 	int transfer_count;
 };
 
-/* This function sets the ID used for profiling trace filename */
 void starpu_profiling_set_id(int new_id);
-
-/* This function sets the profiling status:
- * - enable with STARPU_PROFILING_ENABLE
- * - disable with STARPU_PROFILING_DISABLE
- * Negative return values indicate an error, otherwise the previous status is
- * returned. Calling this function resets the profiling measurements. */
 int starpu_profiling_status_set(int status);
-
-/* Return the current profiling status or a negative value in case there was an
- * error. */
 int starpu_profiling_status_get(void);
+
 #ifdef BUILDING_STARPU
 #include <common/utils.h>
 extern int _starpu_profiling;
@@ -112,8 +96,6 @@ extern int _starpu_profiling;
 })
 #endif
 
-/* Get the profiling info associated to a worker, and reset the profiling
- * measurements. If worker_info is NULL, we only reset the counters. */
 int starpu_profiling_worker_get_info(int workerid, struct starpu_profiling_worker_info *worker_info);
 
 int starpu_bus_get_count(void);
@@ -178,7 +160,6 @@ static __starpu_inline void starpu_timespec_sub(const struct timespec *a,
 #define starpu_timespec_cmp(a, b, CMP)                          \
 	(((a)->tv_sec == (b)->tv_sec) ? ((a)->tv_nsec CMP (b)->tv_nsec) : ((a)->tv_sec CMP (b)->tv_sec))
 
-/* Returns the time elapsed between start and end in microseconds */
 double starpu_timing_timespec_delay_us(struct timespec *start, struct timespec *end);
 double starpu_timing_timespec_to_us(struct timespec *ts);
 

include/starpu_sched_ctx.h

@@ -24,11 +24,6 @@ extern "C"
 {
 #endif
 
-/*
- * MANAGEMENT OF SCHEDULING CONTEXTS
- */
-
-/* create a context indicating the scheduling policy, the workers it should have and a potential name */
 unsigned starpu_sched_ctx_create(const char *policy_name, int *workerids_ctx, int nworkers_ctx, const char *sched_ctx_name);
 
 /* create a context indicating an approximate interval of resources */
@@ -36,13 +31,10 @@ unsigned starpu_sched_ctx_create_inside_interval(const char *policy_name, const
 						 int min_ncpus, int max_ncpus, int min_ngpus, int max_ngpus,
 						 unsigned allow_overlap);
 
-/* add workers to a context */
 void starpu_sched_ctx_add_workers(int *workerids_ctx, int nworkers_ctx, unsigned sched_ctx_id);
 
-/* remove workers from a context */
 void starpu_sched_ctx_remove_workers(int *workerids_ctx, int nworkers_ctx, unsigned sched_ctx_id);
 
-/* delete a certain context */
 void starpu_sched_ctx_delete(unsigned sched_ctx_id);
 
 /* indicate which context whill inherit the resources of this context when he will be deleted */

include/starpu_task_bundle.h

@@ -26,96 +26,14 @@ extern "C"
 
 struct starpu_task;
 
-/* starpu_task_bundle_t
- * ==================
- * Purpose
- * =======
- * Opaque structure describing a list of tasks that should be scheduled
- * on the same worker whenever it's possible.
- * It must be considered as a hint given to the scheduler as there is no guarantee that
- * they will be executed on the same worker.
- */
 typedef struct _starpu_task_bundle *starpu_task_bundle_t;
 
-/* starpu_task_bundle_create
- * =========================
- * Purpose
- * =======
- * Factory function creating a bundle, when the call return,
- * memory needed is allocated and the bundle is ready to use.
- *
- * Arguments
- * =========
- * bundle		(output)
- * 			Bundle to create and initialize.
- */
 void starpu_task_bundle_create(starpu_task_bundle_t *bundle);
 
-/* starpu_task_bundle_insert
- * =========================
- * Purpose
- * =======
- * Insert a task in a bundle. Until the task is removed from the bundle
- * its expected length and data transfer time will be considered along
- * those of the other tasks of the bundle.
- * This function mustn't be called if the bundle is already closed and/or
- * the task is already submitted.
- *
- * Return value
- * ============
- * On success, it returns 0.
- * There are two cases of error :
- * 	- if the bundle is already closed it returns -EPERM
- * 	- if the task was already submitted it return -EINVAL.
- *
- * Arguments
- * =========
- * bundle		(input)
- * 			Bundle where to insert the task.
- *
- * task			(input)
- * 			Task to insert.
- */
 int starpu_task_bundle_insert(starpu_task_bundle_t bundle, struct starpu_task *task);
 
-/* starpu_task_bundle_remove
- * =========================
- * Purpose
- * =======
- * Remove the tasks passed as argument from the bundle.
- * Of course the task must have been previously inserted in the bundle.
- * This function mustn't be called if the bundle is already closed and/or
- * the task is already submitted. Doing so would result in undefined behaviour.
- *
- * Return value
- * ============
- * On success, it returns 0.
- * If the bundle is already closed it returns -ENOENT.
- *
- * Arguments
- * =========
- * bundle		(input)
- * 			Bundle containing the task.
- *
- * task			(input)
- * 			The task to remove.
- */
 int starpu_task_bundle_remove(starpu_task_bundle_t bundle, struct starpu_task *task);
 
-/* starpu_task_bundle_close
- * =========================
- * Purpose
- * =======
- * Calling this functions informs the runtime that the user
- * won't modify the bundle anymore, it means no more
- * inserting or removing a task.
- * Thus the runtime can destroy it when needed.
- *
- * Arguments
- * =========
- * bundle		(input)
- * 			Bundle to close.
- */
 void starpu_task_bundle_close(starpu_task_bundle_t bundle);
 
 #ifdef __cplusplus

include/starpu_task_list.h

@@ -35,41 +35,19 @@ struct starpu_task_list
  * the inline into all .o files! */
 #if !defined(BUILDING_STARPU) || defined(__GNUC_GNU_INLINE__)
 
-/* Initialize a list structure */
 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);
-
-/* Push a task at the back of a list */
 void starpu_task_list_push_back(struct starpu_task_list *list, struct starpu_task *task);
-
-/* Get the front of the list (without removing it) */
 struct starpu_task *starpu_task_list_front(struct starpu_task_list *list);
-
-/* Get the back of the list (without removing it) */
 struct starpu_task *starpu_task_list_back(struct starpu_task_list *list);
-
-/* Test if a list is empty */
 int starpu_task_list_empty(struct starpu_task_list *list);
-
-/* Remove an element from the list */
 void starpu_task_list_erase(struct starpu_task_list *list, struct starpu_task *task);
-
-/* Remove the element at the front of the list */
 struct starpu_task *starpu_task_list_pop_front(struct starpu_task_list *list);
-
-/* Remove the element at the back of the list */
 struct starpu_task *starpu_task_list_pop_back(struct starpu_task_list *list);
-
-/* Get the first task of the list */
 struct starpu_task *starpu_task_list_begin(struct starpu_task_list *list);
-
-/* Get the end of the list */
 struct starpu_task *starpu_task_list_end(struct starpu_task_list *list);
-
-/* Get the next task of the list. This is not erase-safe. */
 struct starpu_task *starpu_task_list_next(struct starpu_task *task);
+
 #endif
 
 #ifdef __cplusplus

include/starpu_util.h

@@ -243,11 +243,6 @@ static __starpu_inline int starpu_get_env_number(const char *str)
 /* Add an event in the execution trace if FxT is enabled */
 void starpu_trace_user_event(unsigned long code);
 
-/* Call func(arg) on every worker matching the "where" mask (eg.
- * STARPU_CUDA|STARPU_CPU to execute the function on every CPU and every CUDA
- * device). This function is synchronous, but the different workers may execute
- * the function in parallel.
- * */
 void starpu_execute_on_each_worker(void (*func)(void *), void *arg, uint32_t where);
 
 /* Same as starpu_execute_on_each_worker, except that the task name is specified in the "name" parameter. */
@@ -259,13 +254,6 @@ void starpu_execute_on_each_worker_ex(void (*func)(void *), void *arg, uint32_t
  * */
 void starpu_execute_on_specific_workers(void (*func)(void*), void * arg, unsigned num_workers, unsigned * workers, const char * name);
 
-/* Copy the content of the src_handle into the dst_handle handle.  The
- * asynchronous parameter indicates whether the function should block or not.
- * In the case of an asynchronous call, it is possible to synchronize with the
- * termination of this operation either by the means of implicit dependencies
- * (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 asynchronous, void (*callback_func)(void*), void *callback_arg);
 
 /* Return the current date in us */