Browse Source

move documentation from public include file to doxygen file

Nathalie Furmento 10 years ago
parent
commit
e9e0a96dc5

+ 10 - 10
doc/doxygen/chapters/api/bitmap.doxy

@@ -10,27 +10,27 @@
 
 
 \fn struct starpu_bitmap *starpu_bitmap_create(void)
 \fn struct starpu_bitmap *starpu_bitmap_create(void)
 \ingroup API_Bitmap
 \ingroup API_Bitmap
-todo
+create a empty starpu_bitmap
 
 
 \fn void starpu_bitmap_destroy(struct starpu_bitmap *b)
 \fn void starpu_bitmap_destroy(struct starpu_bitmap *b)
 \ingroup API_Bitmap
 \ingroup API_Bitmap
-todo
+free a starpu_bitmap
 
 
 \fn void starpu_bitmap_set(struct starpu_bitmap *b, int e)
 \fn void starpu_bitmap_set(struct starpu_bitmap *b, int e)
 \ingroup API_Bitmap
 \ingroup API_Bitmap
-todo
+set bit \p e in \p b
 
 
 \fn void starpu_bitmap_unset(struct starpu_bitmap *b, int e)
 \fn void starpu_bitmap_unset(struct starpu_bitmap *b, int e)
 \ingroup API_Bitmap
 \ingroup API_Bitmap
-todo
+unset bit \p e in \p b
 
 
 \fn void starpu_bitmap_unset_all(struct starpu_bitmap *b)
 \fn void starpu_bitmap_unset_all(struct starpu_bitmap *b)
 \ingroup API_Bitmap
 \ingroup API_Bitmap
-todo
+unset all bits in \b b
 
 
 \fn int starpu_bitmap_get(struct starpu_bitmap *b, int e)
 \fn int starpu_bitmap_get(struct starpu_bitmap *b, int e)
 \ingroup API_Bitmap
 \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)
 \fn void starpu_bitmap_unset_and(struct starpu_bitmap *a, struct starpu_bitmap *b, struct starpu_bitmap *c)
 \ingroup API_Bitmap
 \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)
 \fn int starpu_bitmap_cardinal(struct starpu_bitmap *b)
 \ingroup API_Bitmap
 \ingroup API_Bitmap
-todo
+return the number of set bits in \p b
 
 
 \fn int starpu_bitmap_first(struct starpu_bitmap *b)
 \fn int starpu_bitmap_first(struct starpu_bitmap *b)
 \ingroup API_Bitmap
 \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)
 \fn int starpu_bitmap_last(struct starpu_bitmap *b)
 \ingroup API_Bitmap
 \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)
 \fn int starpu_bitmap_next(struct starpu_bitmap *b, int e)
 \ingroup API_Bitmap
 \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)
 \fn int starpu_bitmap_has_next(struct starpu_bitmap *b, int e)
 \ingroup API_Bitmap
 \ingroup API_Bitmap

+ 100 - 62
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]
 \var struct starpu_sched_component *starpu_sched_tree::worker_components[STARPU_NMAXWORKERS]
      	worker components
      	worker components
 
 
+@name Scheduling Tree API
+\ingroup API_Modularized_Scheduler
+
 \fn struct starpu_sched_tree *starpu_sched_tree_create(unsigned sched_ctx_id)
 \fn struct starpu_sched_tree *starpu_sched_tree_create(unsigned sched_ctx_id)
 \ingroup API_Modularized_Scheduler
 \ingroup API_Modularized_Scheduler
 	 create a empty initialized starpu_sched_tree
 	 create a empty initialized starpu_sched_tree
@@ -135,7 +138,32 @@ The actual scheduler
 \ingroup API_Modularized_Scheduler
 \ingroup API_Modularized_Scheduler
 	 destroy tree and free all non shared component in it.
 	 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)
 \fn struct starpu_sched_component *starpu_sched_component_create(struct starpu_sched_tree *tree)
 \ingroup API_Modularized_Scheduler
 \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)
 	 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
 	 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)
 \fn int starpu_sched_component_can_execute_task(struct starpu_sched_component *component, struct starpu_task *task)
 \ingroup API_Modularized_Scheduler
 \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
 	 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
 \ingroup API_Modularized_Scheduler
 	 return the average time to transfer \p task data to underlying \p component workers.
 	 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)
 \fn struct starpu_sched_component *starpu_sched_component_worker_get(unsigned sched_ctx, int workerid)
 \ingroup API_Modularized_Scheduler
 \ingroup API_Modularized_Scheduler
 	 return the struct starpu_sched_component corresponding to \p workerid. Undefined if \p workerid is not a valid workerid
 	 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)
 \fn int starpu_sched_component_is_worker(struct starpu_sched_component *component)
 \ingroup API_Modularized_Scheduler
 \ingroup API_Modularized_Scheduler
 	 return true iff \p component is a worker component
 	 return true iff \p component is a worker component
@@ -184,9 +223,17 @@ The actual scheduler
 \ingroup API_Modularized_Scheduler
 \ingroup API_Modularized_Scheduler
 	 return true iff \p component is a combined worker component
 	 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
 \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)
 \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
 \ingroup API_Modularized_Scheduler
@@ -198,121 +245,112 @@ The actual scheduler
 \ingroup API_Modularized_Scheduler
 \ingroup API_Modularized_Scheduler
 	 return true iff \p component is a fifo component
 	 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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \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
 \struct starpu_sched_component_composed_recipe
 \ingroup API_Modularized_Scheduler
 \ingroup API_Modularized_Scheduler

+ 2 - 90
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);
 	void (*remove_parent)(struct starpu_sched_component *component, struct starpu_sched_component *parent);
 
 
 	int (*push_task)(struct starpu_sched_component *, struct starpu_task *);
 	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);
 	int (*can_push)(struct starpu_sched_component *component);
 	void (*can_pull)(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;
 	starpu_pthread_mutex_t lock;
 };
 };
 
 
-/*******************************************************************************
- *							Scheduling Tree's Interface 					   *
- ******************************************************************************/
-
 struct starpu_sched_tree *starpu_sched_tree_create(unsigned sched_ctx_id);
 struct starpu_sched_tree *starpu_sched_tree_create(unsigned sched_ctx_id);
 void starpu_sched_tree_destroy(struct starpu_sched_tree *tree);
 void starpu_sched_tree_destroy(struct starpu_sched_tree *tree);
 struct starpu_sched_tree *starpu_sched_tree_get(unsigned sched_ctx_id);
 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);
 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);
 void starpu_sched_tree_update_workers_in_ctx(struct starpu_sched_tree *t);
-
 int starpu_sched_tree_push_task(struct starpu_task *task);
 int starpu_sched_tree_push_task(struct starpu_task *task);
 struct starpu_task *starpu_sched_tree_pop_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_add_workers(unsigned sched_ctx_id, int *workerids, unsigned nworkers);
 void starpu_sched_tree_remove_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);
 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(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_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);
 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);
 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);
 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);
 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);
 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_worker(struct starpu_sched_component *component);
 int starpu_sched_component_is_simple_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);
 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_pre_exec_hook(struct starpu_task *task);
 void starpu_sched_component_worker_post_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
 struct starpu_fifo_data
 {
 {
 	unsigned ntasks_threshold;
 	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);
 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);
 int starpu_sched_component_is_fifo(struct starpu_sched_component *component);
 
 
-/*******************************************************************************
- *					Flow-control Prio Component's Interface 				   *
- ******************************************************************************/
-
 struct starpu_prio_data
 struct starpu_prio_data
 {
 {
 	unsigned ntasks_threshold;
 	unsigned ntasks_threshold;
 	double exp_len_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);
 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);
 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);
 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_component_is_work_stealing(struct starpu_sched_component *component);
 int starpu_sched_tree_work_stealing_push_task(struct starpu_task *task);
 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);
 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 *);
 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);
 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 *);
 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);
 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 *);
 int starpu_sched_component_is_eager_calibration(struct starpu_sched_component *);
 
 
-/*******************************************************************************
- *				Resource-mapping MCT Component's Interface 					   *
- ******************************************************************************/
-
 struct starpu_mct_data
 struct starpu_mct_data
 {
 {
 	double alpha;
 	double alpha;
@@ -203,29 +146,12 @@ struct starpu_mct_data
 	double gamma;
 	double gamma;
 	double idle_power;
 	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);
 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);
 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);
 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);
 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_sched_component *starpu_sched_component_best_implementation_create(struct starpu_sched_tree *tree, void *arg STARPU_ATTRIBUTE_UNUSED);
 
 
 struct starpu_perfmodel_select_data
 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 *no_perfmodel_component;
 	struct starpu_sched_component *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);
 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);
 int starpu_sched_component_is_perfmodel_select(struct starpu_sched_component *component);
 
 
-/*******************************************************************************
- *						Recipe Component's Interface	 					   *
- ******************************************************************************/
-
 struct starpu_sched_component_composed_recipe;
 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(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);
 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_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 *);
 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);
 struct starpu_sched_component *starpu_sched_component_composed_component_create(struct starpu_sched_tree *tree, struct starpu_sched_component_composed_recipe *recipe);