move documentation from public include file to doxygen file

doc/doxygen/chapters/api/bitmap.doxy

@@ -10,27 +10,27 @@
 
 \fn struct starpu_bitmap *starpu_bitmap_create(void)
 \ingroup API_Bitmap
-todo
+create a empty starpu_bitmap
 
 \fn void starpu_bitmap_destroy(struct starpu_bitmap *b)
 \ingroup API_Bitmap
-todo
+free a starpu_bitmap
 
 \fn void starpu_bitmap_set(struct starpu_bitmap *b, int e)
 \ingroup API_Bitmap
-todo
+set bit \p e in \p b
 
 \fn void starpu_bitmap_unset(struct starpu_bitmap *b, int e)
 \ingroup API_Bitmap
-todo
+unset bit \p e in \p b
 
 \fn void starpu_bitmap_unset_all(struct starpu_bitmap *b)
 \ingroup API_Bitmap
-todo
+unset all bits in \b b
 
 \fn int starpu_bitmap_get(struct starpu_bitmap *b, int e)
 \ingroup API_Bitmap
-todo
+return true iff bit \p e is set in \p b
 
 \fn void starpu_bitmap_unset_and(struct starpu_bitmap *a, struct starpu_bitmap *b, struct starpu_bitmap *c)
 \ingroup API_Bitmap
@@ -46,19 +46,19 @@ return 1 iff e set in b1 AND e set in b2
 
 \fn int starpu_bitmap_cardinal(struct starpu_bitmap *b)
 \ingroup API_Bitmap
-todo
+return the number of set bits in \p b
 
 \fn int starpu_bitmap_first(struct starpu_bitmap *b)
 \ingroup API_Bitmap
-return the index of first bit, -1 if none
+return the index of first set bit of \p b, -1 if none
 
 \fn int starpu_bitmap_last(struct starpu_bitmap *b)
 \ingroup API_Bitmap
-todo
+return the position of the last set bit of \p b, -1 if none
 
 \fn int starpu_bitmap_next(struct starpu_bitmap *b, int e)
 \ingroup API_Bitmap
-return the index of bit right after e, -1 if none
+return the position of set bit right after \p e in \p b, -1 if none
 
 \fn int starpu_bitmap_has_next(struct starpu_bitmap *b, int e)
 \ingroup API_Bitmap

doc/doxygen/chapters/api/modularized_scheduler.doxy

@@ -127,6 +127,9 @@ The actual scheduler
 \var struct starpu_sched_component *starpu_sched_tree::worker_components[STARPU_NMAXWORKERS]
      	worker components
 
+@name Scheduling Tree API
+\ingroup API_Modularized_Scheduler
+
 \fn struct starpu_sched_tree *starpu_sched_tree_create(unsigned sched_ctx_id)
 \ingroup API_Modularized_Scheduler
 	 create a empty initialized starpu_sched_tree
@@ -135,7 +138,32 @@ The actual scheduler
 \ingroup API_Modularized_Scheduler
 	 destroy tree and free all non shared component in it.
 
+\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)
+\ingroup API_Modularized_Scheduler
+	 recursively set all starpu_sched_component::workers_in_ctx, do not take into account shared parts (except workers)
+
+\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()
+\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)
+\ingroup API_Modularized_Scheduler
+	 compatibility with starpu_sched_policy interface
+
+\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
+
+@name Generic Scheduling Component API
+\ingroup API_Modularized_Scheduler
 
 \fn struct starpu_sched_component *starpu_sched_component_create(struct starpu_sched_tree *tree)
 \ingroup API_Modularized_Scheduler
@@ -153,6 +181,10 @@ The actual 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_destroy_rec(struct starpu_sched_component *component)
+\ingroup API_Modularized_Scheduler
+	 recursively destroy non shared parts of a \p component 's tree
+
 \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
@@ -168,10 +200,17 @@ The actual scheduler
 \ingroup API_Modularized_Scheduler
 	 return the average time to transfer \p task data to underlying \p component workers.
 
+@name Worker Component API
+\ingroup API_Modularized_Scheduler
+
 \fn struct starpu_sched_component *starpu_sched_component_worker_get(unsigned sched_ctx, 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_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 int starpu_sched_component_is_worker(struct starpu_sched_component *component)
 \ingroup API_Modularized_Scheduler
 	 return true iff \p component is a worker component
@@ -184,9 +223,17 @@ The actual scheduler
 \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 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)
+\ingroup API_Modularized_Scheduler
+	 compatibility with starpu_sched_policy interface
+
+@name Flow-control Fifo Component API
 \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(struct starpu_sched_tree *tree, struct starpu_fifo_data *fifo_data)
 \ingroup API_Modularized_Scheduler
@@ -198,121 +245,112 @@ The actual scheduler
 \ingroup API_Modularized_Scheduler
 	 return true iff \p component is a fifo component
 
-\fn struct starpu_sched_component *starpu_sched_component_work_stealing_create(struct starpu_sched_tree *tree, void *arg)
+@name Flow-control Prio Component API
 \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.
 
-\fn int starpu_sched_tree_work_stealing_push_task(struct starpu_task *task)
+\fn struct starpu_sched_component *starpu_sched_component_prio_create(struct starpu_sched_tree *tree, struct starpu_prio_data *prio_data)
 \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.
+todo
 
-\fn int starpu_sched_component_is_work_stealing(struct starpu_sched_component *component)
+\fn int starpu_sched_component_is_prio(struct starpu_sched_component *component)
 \ingroup API_Modularized_Scheduler
-	 return true iff \p component is a work stealing component
+todo
 
-\fn struct starpu_sched_component *starpu_sched_component_random_create(struct starpu_sched_tree *tree, void *arg)
+@name Resource-mapping Work-Stealing Component API
 \ingroup API_Modularized_Scheduler
-	 create a component that perform a random scheduling
 
-\fn int starpu_sched_component_is_random(struct starpu_sched_component *)
+\fn struct starpu_sched_component *starpu_sched_component_work_stealing_create(struct starpu_sched_tree *tree, void *arg)
 \ingroup API_Modularized_Scheduler
-	 return true iff \p component is a random component
+	 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.
 
-\fn struct starpu_sched_component *starpu_sched_component_heft_create(struct starpu_sched_tree *tree, struct starpu_mct_data *mct_data)
+\fn int starpu_sched_tree_work_stealing_push_task(struct starpu_task *task)
 \ingroup API_Modularized_Scheduler
-	 this component perform a heft scheduling
+	 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_heft(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 heft component
+	 return true iff \p component is a work stealing component
 
-\fn struct starpu_sched_component *starpu_sched_component_best_implementation_create(struct starpu_sched_tree *tree, void *arg)
+@name Resource-mapping Random Component API
 \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.
-	 Also set starpu_task::predicted and starpu_task::predicted_transfer for memory component of the first suitable workerid.
-	 If starpu_sched_component::push method is called and starpu_sched_component::nchild > 1 the result is undefined.
 
-\fn void starpu_sched_component_destroy_rec(struct starpu_sched_component *component)
+\fn struct starpu_sched_component *starpu_sched_component_random_create(struct starpu_sched_tree *tree, void *arg)
 \ingroup API_Modularized_Scheduler
-	 recursively destroy non shared parts of a \p component 's tree
+	 create a component that perform a random scheduling
 
-\fn int starpu_sched_tree_push_task(struct starpu_task *task)
+\fn int starpu_sched_component_is_random(struct starpu_sched_component *)
 \ingroup API_Modularized_Scheduler
-	 compatibility with starpu_sched_policy interface
+	 return true iff \p component is a random component
 
-\fn struct starpu_task *starpu_sched_tree_pop_task()
+@name Resource-mapping Eager Component API
 \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)
+\fn struct starpu_sched_component *starpu_sched_component_eager_create(struct starpu_sched_tree *tree, void *arg STARPU_ATTRIBUTE_UNUSED);
 \ingroup API_Modularized_Scheduler
-	 compatibility with starpu_sched_policy interface
+todo
 
-\fn void starpu_sched_tree_remove_workers(unsigned sched_ctx_id, int *workerids, unsigned nworkers)
+\fn int starpu_sched_component_is_eager(struct starpu_sched_component *)
 \ingroup API_Modularized_Scheduler
-	 compatibility with starpu_sched_policy interface
+todo
 
-\fn void starpu_sched_component_worker_pre_exec_hook(struct starpu_task *task)
+@name Resource-mapping Eager-Calibration Component API
 \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 struct starpu_sched_component *starpu_sched_component_eager_calibration_create(struct starpu_sched_tree *tree, void *arg STARPU_ATTRIBUTE_UNUSED)
 \ingroup API_Modularized_Scheduler
-	 compatibility with starpu_sched_policy interface
+todo
 
-\fn void starpu_sched_tree_update_workers(struct starpu_sched_tree *t)
+\fn int starpu_sched_component_is_eager_calibration(struct starpu_sched_component *)
 \ingroup API_Modularized_Scheduler
-	 recursively set all starpu_sched_component::workers, do not take into account shared parts (except workers).
+todo
 
-\fn void starpu_sched_tree_update_workers_in_ctx(struct starpu_sched_tree *t)
+@name Resource-mapping MCT Component API
 \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
+\fn struct starpu_sched_component *starpu_sched_component_mct_create(struct starpu_sched_tree *tree, struct starpu_mct_data *mct_data)
 \ingroup API_Modularized_Scheduler
-	 implement a simple bitmap
+create a component with mct_data paremeters. the mct component doesnt
+do anything but pushing tasks on no_perf_model_component and
+calibrating_component
 
-\fn struct starpu_bitmap *starpu_bitmap_create(void)
+\fn int starpu_sched_component_is_mct(struct starpu_sched_component *component);
 \ingroup API_Modularized_Scheduler
-	 create a empty starpu_bitmap
+todo
 
-\fn void starpu_bitmap_destroy(struct starpu_bitmap *b)
+@name Resource-mapping Heft Component API
 \ingroup API_Modularized_Scheduler
-	 free a starpu_bitmap
 
-\fn void starpu_bitmap_set(struct starpu_bitmap *b, int e)
+\fn struct starpu_sched_component *starpu_sched_component_heft_create(struct starpu_sched_tree *tree, struct starpu_mct_data *mct_data)
 \ingroup API_Modularized_Scheduler
-	 set bit \p e in \p b
+	 this component perform a heft scheduling
 
-\fn void starpu_bitmap_unset(struct starpu_bitmap *b, int e)
+\fn int starpu_sched_component_is_heft(struct starpu_sched_component *component)
 \ingroup API_Modularized_Scheduler
-	 unset bit \p e in \p b
+	 return true iff \p component is a heft component
 
-\fn void starpu_bitmap_unset_all(struct starpu_bitmap *b)
+@name Special-purpose Best_Implementation Component API
 \ingroup API_Modularized_Scheduler
-	 unset all bits in \b b
 
-\fn int starpu_bitmap_get(struct starpu_bitmap *b, int e)
+\fn struct starpu_sched_component *starpu_sched_component_best_implementation_create(struct starpu_sched_tree *tree, void *arg)
 \ingroup API_Modularized_Scheduler
-	 return true iff bit \p e is set in \p b
+	 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.
+	 Also set starpu_task::predicted and starpu_task::predicted_transfer for memory component of the first suitable workerid.
+	 If starpu_sched_component::push method is called and starpu_sched_component::nchild > 1 the result is undefined.
 
-\fn int starpu_bitmap_cardinal(struct starpu_bitmap *b)
+@name Special-purpose Perfmodel_Select Component API
 \ingroup API_Modularized_Scheduler
-	 return the number of set bits in \p b
 
-\fn int starpu_bitmap_first(struct starpu_bitmap *b)
+\fn struct starpu_sched_component *starpu_sched_component_perfmodel_select_create(struct starpu_sched_tree *tree, struct starpu_perfmodel_select_data *perfmodel_select_data)
 \ingroup API_Modularized_Scheduler
-	 return the position of the first set bit of \p b, -1 if none
+todo
 
-\fn int starpu_bitmap_last(struct starpu_bitmap *b)
+\fn int starpu_sched_component_is_perfmodel_select(struct starpu_sched_component *component)
 \ingroup API_Modularized_Scheduler
-	 return the position of the last set bit of \p b, -1 if none
+todo
 
-\fn int starpu_bitmap_next(struct starpu_bitmap *b, int e)
+@name Recipe Component API
 \ingroup API_Modularized_Scheduler
-	 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

include/starpu_sched_component.h

@@ -55,7 +55,7 @@ struct starpu_sched_component
 	void (*remove_parent)(struct starpu_sched_component *component, struct starpu_sched_component *parent);
 
 	int (*push_task)(struct starpu_sched_component *, struct starpu_task *);
-	struct starpu_task * (*pull_task)(struct starpu_sched_component *);
+	struct starpu_task *(*pull_task)(struct starpu_sched_component *);
 
 	int (*can_push)(struct starpu_sched_component *component);
 	void (*can_pull)(struct starpu_sched_component *component);
@@ -83,64 +83,32 @@ struct starpu_sched_tree
 	starpu_pthread_mutex_t lock;
 };
 
-/*******************************************************************************
- *							Scheduling Tree's Interface 					   *
- ******************************************************************************/
-
 struct starpu_sched_tree *starpu_sched_tree_create(unsigned sched_ctx_id);
 void starpu_sched_tree_destroy(struct starpu_sched_tree *tree);
 struct starpu_sched_tree *starpu_sched_tree_get(unsigned sched_ctx_id);
-
-/* destroy component and all his child
- * except if they are shared between several contexts
- */
-void starpu_sched_component_destroy_rec(struct starpu_sched_component *component);
-
-/* update all the component->workers member recursively
- */
 void starpu_sched_tree_update_workers(struct starpu_sched_tree *t);
-/* idem for workers_in_ctx
- */
 void starpu_sched_tree_update_workers_in_ctx(struct starpu_sched_tree *t);
-
 int starpu_sched_tree_push_task(struct starpu_task *task);
 struct starpu_task *starpu_sched_tree_pop_task();
-
 void starpu_sched_tree_add_workers(unsigned sched_ctx_id, int *workerids, unsigned nworkers);
 void starpu_sched_tree_remove_workers(unsigned sched_ctx_id, int *workerids, unsigned nworkers);
 
-/*******************************************************************************
- *					Generic Scheduling Component's Interface 				   *
- ******************************************************************************/
-
 struct starpu_sched_component *starpu_sched_component_create(struct starpu_sched_tree *tree);
 void starpu_sched_component_destroy(struct starpu_sched_component *component);
-
+void starpu_sched_component_destroy_rec(struct starpu_sched_component *component);
 int starpu_sched_component_can_execute_task(struct starpu_sched_component *component, struct starpu_task *task);
 int STARPU_WARN_UNUSED_RESULT starpu_sched_component_execute_preds(struct starpu_sched_component *component, struct starpu_task *task, double *length);
 double starpu_sched_component_transfer_length(struct starpu_sched_component *component, struct starpu_task *task);
 void starpu_sched_component_prefetch_on_node(struct starpu_sched_component *component, struct starpu_task *task);
 
-/*******************************************************************************
- *							Worker Component's Interface 				   	   *
- ******************************************************************************/
-
-/* no public create function for workers because we dont want to have several component_worker for a single workerid */
 struct starpu_sched_component *starpu_sched_component_worker_get(unsigned sched_ctx, int workerid);
 int starpu_sched_component_worker_get_workerid(struct starpu_sched_component *worker_component);
-
-/* this function compare the available function of the component with the standard available for worker components*/
 int starpu_sched_component_is_worker(struct starpu_sched_component *component);
 int starpu_sched_component_is_simple_worker(struct starpu_sched_component *component);
 int starpu_sched_component_is_combined_worker(struct starpu_sched_component *component);
-
 void starpu_sched_component_worker_pre_exec_hook(struct starpu_task *task);
 void starpu_sched_component_worker_post_exec_hook(struct starpu_task *task);
 
-/*******************************************************************************
- *					Flow-control Fifo Component's Interface 				   *
- ******************************************************************************/
-
 struct starpu_fifo_data
 {
 	unsigned ntasks_threshold;
@@ -150,52 +118,27 @@ struct starpu_fifo_data
 struct starpu_sched_component *starpu_sched_component_fifo_create(struct starpu_sched_tree *tree, struct starpu_fifo_data *fifo_data);
 int starpu_sched_component_is_fifo(struct starpu_sched_component *component);
 
-/*******************************************************************************
- *					Flow-control Prio Component's Interface 				   *
- ******************************************************************************/
-
 struct starpu_prio_data
 {
 	unsigned ntasks_threshold;
 	double exp_len_threshold;
 };
-
 struct starpu_sched_component *starpu_sched_component_prio_create(struct starpu_sched_tree *tree, struct starpu_prio_data *prio_data);
 int starpu_sched_component_is_prio(struct starpu_sched_component *component);
 
-/*******************************************************************************
- *			Resource-mapping Work-Stealing Component's Interface 			   *
- ******************************************************************************/
-
 struct starpu_sched_component *starpu_sched_component_work_stealing_create(struct starpu_sched_tree *tree, void *arg STARPU_ATTRIBUTE_UNUSED);
 int starpu_sched_component_is_work_stealing(struct starpu_sched_component *component);
 int starpu_sched_tree_work_stealing_push_task(struct starpu_task *task);
 
-/*******************************************************************************
- *				Resource-mapping Random Component's Interface 			   	   *
- ******************************************************************************/
-
 struct starpu_sched_component *starpu_sched_component_random_create(struct starpu_sched_tree *tree, void *arg STARPU_ATTRIBUTE_UNUSED);
 int starpu_sched_component_is_random(struct starpu_sched_component *);
 
-/*******************************************************************************
- *				Resource-mapping Eager Component's Interface 				   *
- ******************************************************************************/
-
 struct starpu_sched_component *starpu_sched_component_eager_create(struct starpu_sched_tree *tree, void *arg STARPU_ATTRIBUTE_UNUSED);
 int starpu_sched_component_is_eager(struct starpu_sched_component *);
 
-/*******************************************************************************
- *			Resource-mapping Eager-Calibration Component's Interface 		   *
- ******************************************************************************/
-
 struct starpu_sched_component *starpu_sched_component_eager_calibration_create(struct starpu_sched_tree *tree, void *arg STARPU_ATTRIBUTE_UNUSED);
 int starpu_sched_component_is_eager_calibration(struct starpu_sched_component *);
 
-/*******************************************************************************
- *				Resource-mapping MCT Component's Interface 					   *
- ******************************************************************************/
-
 struct starpu_mct_data
 {
 	double alpha;
@@ -203,29 +146,12 @@ struct starpu_mct_data
 	double gamma;
 	double idle_power;
 };
-
-/* create a component with mct_data paremeters
-   a copy the struct starpu_mct_data * given is performed during the init_data call
-   the mct component doesnt do anything but pushing tasks on no_perf_model_component and calibrating_component
-*/
 struct starpu_sched_component *starpu_sched_component_mct_create(struct starpu_sched_tree *tree, struct starpu_mct_data *mct_data);
 int starpu_sched_component_is_mct(struct starpu_sched_component *component);
 
-/*******************************************************************************
- *				Resource-mapping HEFT Component's Interface 				   *
- ******************************************************************************/
-
 struct starpu_sched_component *starpu_sched_component_heft_create(struct starpu_sched_tree *tree, struct starpu_mct_data *mct_data);
 int starpu_sched_component_is_heft(struct starpu_sched_component *component);
 
-/*******************************************************************************
- *		Special-purpose Best_Implementation Component's Interface 			   *
- ******************************************************************************/
-
-/* this component select the best implementation for the first worker in context that can execute task.
- * and fill task->predicted and task->predicted_transfer
- * cannot have several child if push_task is called
- */
 struct starpu_sched_component *starpu_sched_component_best_implementation_create(struct starpu_sched_tree *tree, void *arg STARPU_ATTRIBUTE_UNUSED);
 
 struct starpu_perfmodel_select_data
@@ -234,27 +160,13 @@ struct starpu_perfmodel_select_data
 	struct starpu_sched_component *no_perfmodel_component;
 	struct starpu_sched_component *perfmodel_component;
 };
-
-/*******************************************************************************
- *			Special-purpose Perfmodel_Select Component's Interface	 		   *
- ******************************************************************************/
-
 struct starpu_sched_component *starpu_sched_component_perfmodel_select_create(struct starpu_sched_tree *tree, struct starpu_perfmodel_select_data *perfmodel_select_data);
 int starpu_sched_component_is_perfmodel_select(struct starpu_sched_component *component);
 
-/*******************************************************************************
- *						Recipe Component's Interface	 					   *
- ******************************************************************************/
-
 struct starpu_sched_component_composed_recipe;
-
-/* create empty recipe */
 struct starpu_sched_component_composed_recipe *starpu_sched_component_create_recipe(void);
 struct starpu_sched_component_composed_recipe *starpu_sched_component_create_recipe_singleton(struct starpu_sched_component *(*create_component)(struct starpu_sched_tree *tree, void *arg), void *arg);
-
-/* add a function creation component to recipe */
 void starpu_sched_recipe_add_component(struct starpu_sched_component_composed_recipe *recipe, struct starpu_sched_component *(*create_component)(struct starpu_sched_tree *tree, void *arg), void *arg);
-
 void starpu_destroy_composed_sched_component_recipe(struct starpu_sched_component_composed_recipe *);
 struct starpu_sched_component *starpu_sched_component_composed_component_create(struct starpu_sched_tree *tree, struct starpu_sched_component_composed_recipe *recipe);