Add tree field to components, to make it easy to access the sched_ctx_id, notably

include/starpu_sched_component.h

@@ -44,6 +44,9 @@ enum starpu_sched_component_properties
  */
 struct starpu_sched_component
 {
+	/* The tree containing the component */
+	struct starpu_sched_tree *tree;
+
 	/* the set of workers in the component's subtree
 	 */
 	struct starpu_bitmap * workers;
@@ -144,6 +147,10 @@ struct starpu_sched_tree
 	struct starpu_sched_component * root;
 	struct starpu_bitmap * workers;
 	unsigned sched_ctx_id;
+
+	/* this array store worker components */
+	struct starpu_sched_component * worker_components[STARPU_NMAXWORKERS];
+
 	/* this lock is used to protect the scheduler,
 	 * it is taken in read mode pushing a task
 	 * and in write mode for adding or removing workers
@@ -159,6 +166,7 @@ struct starpu_sched_tree
  */
 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_get_tree(unsigned sched_ctx_id);
 
 /* destroy component and all his child
  * except if they are shared between several contexts
@@ -182,7 +190,7 @@ void starpu_sched_tree_remove_workers(unsigned sched_ctx_id, int *workerids, uns
  *					Generic Scheduling Component's Interface 				   *
  ******************************************************************************/
 
-struct starpu_sched_component * starpu_sched_component_create(void);
+struct starpu_sched_component * starpu_sched_component_create(struct starpu_sched_tree *tree);
 void starpu_sched_component_destroy(struct starpu_sched_component * component);
 
 int starpu_sched_component_can_execute_task(struct starpu_sched_component * component, struct starpu_task * task);
@@ -195,7 +203,7 @@ void starpu_sched_component_prefetch_on_node(struct starpu_sched_component * com
  ******************************************************************************/
 
 /* 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(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);
 
 /* this function compare the available function of the component with the standard available for worker components*/
@@ -216,7 +224,7 @@ struct starpu_fifo_data
 	double exp_len_threshold;
 };
 
-struct starpu_sched_component * starpu_sched_component_fifo_create(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);
 
 /*******************************************************************************
@@ -229,14 +237,14 @@ struct starpu_prio_data
 	double exp_len_threshold;
 };
 
-struct starpu_sched_component * starpu_sched_component_prio_create(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);
 
 /*******************************************************************************
  *			Resource-mapping Work-Stealing Component's Interface 			   *
  ******************************************************************************/
 
-struct starpu_sched_component * starpu_sched_component_work_stealing_create(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_tree_work_stealing_push_task(struct starpu_task *task);
 
@@ -244,21 +252,21 @@ 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(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 *);
 
 /*******************************************************************************
  *				Resource-mapping Eager Component's Interface 				   *
  ******************************************************************************/
 
-struct starpu_sched_component * starpu_sched_component_eager_create(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 *);
 
 /*******************************************************************************
  *			Resource-mapping Eager-Calibration Component's Interface 		   *
  ******************************************************************************/
 
-struct starpu_sched_component * starpu_sched_component_eager_calibration_create(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 *);
 
 /*******************************************************************************
@@ -277,14 +285,14 @@ struct starpu_mct_data
    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_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);
 
 /*******************************************************************************
  *				Resource-mapping HEFT Component's Interface 				   *
  ******************************************************************************/
 
-struct starpu_sched_component * starpu_sched_component_heft_create(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);
 
 /*******************************************************************************
@@ -295,7 +303,7 @@ int starpu_sched_component_is_heft(struct starpu_sched_component * component);
  * 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(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
 {
@@ -308,7 +316,7 @@ struct starpu_perfmodel_select_data
  *			Special-purpose Perfmodel_Select Component's Interface	 		   *
  ******************************************************************************/
 
-struct starpu_sched_component * starpu_sched_component_perfmodel_select_create(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);
 
 /*******************************************************************************
@@ -319,13 +327,13 @@ 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)(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)(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 *);
-struct starpu_sched_component * starpu_sched_component_composed_component_create(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);
 
 
 #ifdef STARPU_HAVE_HWLOC

src/sched_policies/component_best_implementation.c

@@ -104,9 +104,9 @@ static struct starpu_task * best_implementation_pull_task(struct starpu_sched_co
 	return task;
 }
 
-struct starpu_sched_component * starpu_sched_component_best_implementation_create(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_sched_component * component = starpu_sched_component_create();
+	struct starpu_sched_component * component = starpu_sched_component_create(tree);
 	component->push_task = best_implementation_push_task;
 	component->pull_task = best_implementation_pull_task;
 	return component;

src/sched_policies/component_composed.c

@@ -23,7 +23,7 @@
  * (create_component_function(arg), arg)
  */
 LIST_TYPE(fun_create_component,
-	  struct starpu_sched_component *(*create_component)(void * arg);
+	  struct starpu_sched_component *(*create_component)(struct starpu_sched_tree *tree, void * arg);
 	  void * arg;
 );
 
@@ -42,7 +42,7 @@ struct starpu_sched_component_composed_recipe * starpu_sched_component_create_re
 }
 
 void starpu_sched_recipe_add_component(struct starpu_sched_component_composed_recipe * recipe,
-				  struct starpu_sched_component *(*create_component)(void * arg),
+				  struct starpu_sched_component *(*create_component)(struct starpu_sched_tree *tree, void * arg),
 				  void * arg)
 {
 	struct fun_create_component * e = fun_create_component_new();
@@ -50,7 +50,7 @@ void starpu_sched_recipe_add_component(struct starpu_sched_component_composed_re
 	e->arg = arg;
 	fun_create_component_list_push_back(recipe->list, e);
 }
-struct starpu_sched_component_composed_recipe * starpu_sched_component_create_recipe_singleton(struct starpu_sched_component *(*create_component)(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)
 {
 	struct starpu_sched_component_composed_recipe * r = starpu_sched_component_create_recipe();
@@ -77,7 +77,7 @@ struct composed_component
 /* this function actualy build the composed component data by changing the list of
  * (component_create_fun, arg_create_fun) into a tree where all components have 1 childs
  */
-struct composed_component create_composed_component(struct starpu_sched_component_composed_recipe * recipe
+struct composed_component create_composed_component(struct starpu_sched_tree *tree, struct starpu_sched_component_composed_recipe * recipe
 #ifdef STARPU_HAVE_HWLOC
 					  ,hwloc_obj_t obj
 #endif
@@ -89,8 +89,8 @@ struct composed_component create_composed_component(struct starpu_sched_componen
 	struct fun_create_component_list * list = recipe->list;
 	struct fun_create_component * i = fun_create_component_list_begin(list);
 	STARPU_ASSERT(i);
-	STARPU_ASSERT(i->create_component(i->arg));
-	c.top = c.bottom = i->create_component(i->arg);
+	STARPU_ASSERT(i->create_component);
+	c.top = c.bottom = i->create_component(tree, i->arg);
 #ifdef STARPU_HAVE_HWLOC
 	c.top->obj = obj;
 #endif
@@ -98,8 +98,8 @@ struct composed_component create_composed_component(struct starpu_sched_componen
 	    i != fun_create_component_list_end(list);
 	    i  = fun_create_component_list_next(i))
 	{
-		STARPU_ASSERT(i->create_component(i->arg));
-		struct starpu_sched_component * component = i->create_component(i->arg);
+		STARPU_ASSERT(i->create_component);
+		struct starpu_sched_component * component = i->create_component(tree, i->arg);
 #ifdef STARPU_HAVE_HWLOC
 		component->obj = obj;
 #endif
@@ -203,16 +203,16 @@ void composed_component_deinit_data(struct starpu_sched_component * _component)
 	_component->data = NULL;
 }
 
-struct starpu_sched_component * starpu_sched_component_composed_component_create(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)
 {
 	STARPU_ASSERT(!fun_create_component_list_empty(recipe->list));
 	struct fun_create_component_list * l = recipe->list;
 	if(l->_head == l->_tail)
-		return l->_head->create_component(l->_head->arg);
-	struct starpu_sched_component * component = starpu_sched_component_create();
+		return l->_head->create_component(tree, l->_head->arg);
+	struct starpu_sched_component * component = starpu_sched_component_create(tree);
 
 	struct composed_component * c = malloc(sizeof(struct composed_component));
-	*c = create_composed_component(recipe
+	*c = create_composed_component(tree, recipe
 #ifdef STARPU_HAVE_HWLOC
 				  ,component->obj
 #endif

src/sched_policies/component_eager.c

@@ -64,9 +64,9 @@ int starpu_sched_component_is_eager(struct starpu_sched_component * component)
 	return component->push_task == eager_push_task;
 }
 
-struct starpu_sched_component * starpu_sched_component_eager_create(void * ARG STARPU_ATTRIBUTE_UNUSED)
+struct starpu_sched_component * starpu_sched_component_eager_create(struct starpu_sched_tree *tree, void * arg STARPU_ATTRIBUTE_UNUSED)
 {
-	struct starpu_sched_component * component = starpu_sched_component_create();
+	struct starpu_sched_component * component = starpu_sched_component_create(tree);
 	component->push_task = eager_push_task;
 
 	return component;

src/sched_policies/component_eager_calibration.c

@@ -77,9 +77,9 @@ int starpu_sched_component_is_eager_calibration(struct starpu_sched_component *
 	return component->push_task == eager_calibration_push_task;
 }
 
-struct starpu_sched_component * starpu_sched_component_eager_calibration_create(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)
 {
-	struct starpu_sched_component * component = starpu_sched_component_create();
+	struct starpu_sched_component * component = starpu_sched_component_create(tree);
 	component->push_task = eager_calibration_push_task;
 
 	return component;

src/sched_policies/component_fifo.c

@@ -237,9 +237,9 @@ int starpu_sched_component_is_fifo(struct starpu_sched_component * component)
 	return component->push_task == fifo_push_task;
 }
 
-struct starpu_sched_component * starpu_sched_component_fifo_create(struct starpu_fifo_data * params)
+struct starpu_sched_component * starpu_sched_component_fifo_create(struct starpu_sched_tree *tree, struct starpu_fifo_data * params)
 {
-	struct starpu_sched_component * component = starpu_sched_component_create();
+	struct starpu_sched_component * component = starpu_sched_component_create(tree);
 	struct _starpu_fifo_data * data = malloc(sizeof(*data));
 	data->fifo = _starpu_create_fifo();
 	STARPU_PTHREAD_MUTEX_INIT(&data->mutex,NULL);

src/sched_policies/component_heft.c

@@ -223,9 +223,9 @@ int starpu_sched_component_is_heft(struct starpu_sched_component * component)
 	return component->push_task == heft_push_task;
 }
 
-struct starpu_sched_component * starpu_sched_component_heft_create(struct starpu_mct_data * params)
+struct starpu_sched_component * starpu_sched_component_heft_create(struct starpu_sched_tree *tree, struct starpu_mct_data * params)
 {
-	struct starpu_sched_component * component = starpu_sched_component_create();
+	struct starpu_sched_component * component = starpu_sched_component_create(tree);
 	struct _starpu_mct_data *mct_data = starpu_mct_init_parameters(params);
 	struct _starpu_heft_data *data = malloc(sizeof(*data));
 

src/sched_policies/component_mct.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2013  Université de Bordeaux 1
+ * Copyright (C) 2013-2014  Université de Bordeaux 1
  * Copyright (C) 2013  INRIA
  * Copyright (C) 2013  Simon Archipoff
  *
@@ -115,9 +115,9 @@ int starpu_sched_component_is_mct(struct starpu_sched_component * component)
 	return component->push_task == mct_push_task;
 }
 
-struct starpu_sched_component * starpu_sched_component_mct_create(struct starpu_mct_data * params)
+struct starpu_sched_component * starpu_sched_component_mct_create(struct starpu_sched_tree *tree, struct starpu_mct_data * params)
 {
-	struct starpu_sched_component * component = starpu_sched_component_create();
+	struct starpu_sched_component * component = starpu_sched_component_create(tree);
 	struct _starpu_mct_data *data = starpu_mct_init_parameters(params);
 
 	component->data = data;

src/sched_policies/component_perfmodel_select.c

@@ -66,11 +66,11 @@ int starpu_sched_component_is_perfmodel_select(struct starpu_sched_component * c
 	return component->push_task == perfmodel_select_push_task;
 }
 
-struct starpu_sched_component * starpu_sched_component_perfmodel_select_create(struct starpu_perfmodel_select_data * params)
+struct starpu_sched_component * starpu_sched_component_perfmodel_select_create(struct starpu_sched_tree *tree, struct starpu_perfmodel_select_data * params)
 {
 	STARPU_ASSERT(params);
 	STARPU_ASSERT(params->calibrator_component && params->no_perfmodel_component && params->perfmodel_component);
-	struct starpu_sched_component * component = starpu_sched_component_create();
+	struct starpu_sched_component * component = starpu_sched_component_create(tree);
 
 	struct _starpu_perfmodel_select_data * data = malloc(sizeof(*data));
 	data->calibrator_component = params->calibrator_component;

src/sched_policies/component_prio.c

@@ -253,9 +253,9 @@ int starpu_sched_component_is_prio(struct starpu_sched_component * component)
 	return component->push_task == prio_push_task;
 }
 
-struct starpu_sched_component * starpu_sched_component_prio_create(struct starpu_prio_data * params)
+struct starpu_sched_component * starpu_sched_component_prio_create(struct starpu_sched_tree *tree, struct starpu_prio_data * params)
 {
-	struct starpu_sched_component * component = starpu_sched_component_create();
+	struct starpu_sched_component * component = starpu_sched_component_create(tree);
 	struct _starpu_prio_data * data = malloc(sizeof(*data));
 	_starpu_prio_deque_init(&data->prio);
 	STARPU_PTHREAD_MUTEX_INIT(&data->mutex,NULL);

src/sched_policies/component_random.c

@@ -111,9 +111,9 @@ int starpu_sched_component_is_random(struct starpu_sched_component *component)
 	return component->push_task == random_push_task;
 }
 
-struct starpu_sched_component * starpu_sched_component_random_create(void * arg STARPU_ATTRIBUTE_UNUSED)
+struct starpu_sched_component * starpu_sched_component_random_create(struct starpu_sched_tree *tree, void * arg STARPU_ATTRIBUTE_UNUSED)
 {
-	struct starpu_sched_component * component = starpu_sched_component_create();
+	struct starpu_sched_component * component = starpu_sched_component_create(tree);
 	component->estimated_end = random_estimated_end;
 	component->push_task = random_push_task;
 	return component;

src/sched_policies/component_sched.c

@@ -335,10 +335,10 @@ int starpu_sched_tree_push_task(struct starpu_task * task)
 	return ret_val;
 }
 
-struct starpu_task * starpu_sched_tree_pop_task(unsigned sched_ctx STARPU_ATTRIBUTE_UNUSED)
+struct starpu_task * starpu_sched_tree_pop_task(unsigned sched_ctx)
 {
 	int workerid = starpu_worker_get_id();
-	struct starpu_sched_component * component = starpu_sched_component_worker_get(workerid);
+	struct starpu_sched_component * component = starpu_sched_component_worker_get(sched_ctx, workerid);
 
 	/* _starpu_sched_component_lock_worker(workerid) is called by component->pull_task()
 	 */
@@ -353,7 +353,7 @@ void starpu_sched_tree_add_workers(unsigned sched_ctx_id, int *workerids, unsign
 	struct starpu_sched_tree * t = starpu_sched_ctx_get_policy_data(sched_ctx_id);
 
 	STARPU_PTHREAD_MUTEX_LOCK(&t->lock);
-	_starpu_sched_component_lock_all_workers();
+	_starpu_sched_component_lock_all_workers(sched_ctx_id);
 
 	unsigned i;
 	for(i = 0; i < nworkers; i++)
@@ -361,7 +361,7 @@ void starpu_sched_tree_add_workers(unsigned sched_ctx_id, int *workerids, unsign
 
 	starpu_sched_tree_update_workers_in_ctx(t);
 
-	_starpu_sched_component_unlock_all_workers();
+	_starpu_sched_component_unlock_all_workers(sched_ctx_id);
 	STARPU_PTHREAD_MUTEX_UNLOCK(&t->lock);
 }
 
@@ -372,7 +372,7 @@ void starpu_sched_tree_remove_workers(unsigned sched_ctx_id, int *workerids, uns
 	struct starpu_sched_tree * t = starpu_sched_ctx_get_policy_data(sched_ctx_id);
 
 	STARPU_PTHREAD_MUTEX_LOCK(&t->lock);
-	_starpu_sched_component_lock_all_workers();
+	_starpu_sched_component_lock_all_workers(sched_ctx_id);
 
 	unsigned i;
 	for(i = 0; i < nworkers; i++)
@@ -380,24 +380,30 @@ void starpu_sched_tree_remove_workers(unsigned sched_ctx_id, int *workerids, uns
 
 	starpu_sched_tree_update_workers_in_ctx(t);
 
-	_starpu_sched_component_unlock_all_workers();
+	_starpu_sched_component_unlock_all_workers(sched_ctx_id);
 	STARPU_PTHREAD_MUTEX_UNLOCK(&t->lock);
 }
 
+static struct starpu_sched_tree *trees[STARPU_NMAX_SCHED_CTXS];
+
 struct starpu_sched_tree * starpu_sched_tree_create(unsigned sched_ctx_id)
 {
 	STARPU_ASSERT(sched_ctx_id < STARPU_NMAX_SCHED_CTXS);
+	STARPU_ASSERT(!trees[sched_ctx_id]);
 	struct starpu_sched_tree * t = malloc(sizeof(*t));
 	memset(t, 0, sizeof(*t));
 	t->sched_ctx_id = sched_ctx_id;
 	t->workers = starpu_bitmap_create();
 	STARPU_PTHREAD_MUTEX_INIT(&t->lock,NULL);
+	trees[sched_ctx_id] = t;
 	return t;
 }
 
 void starpu_sched_tree_destroy(struct starpu_sched_tree * tree)
 {
 	STARPU_ASSERT(tree);
+	STARPU_ASSERT(trees[tree->sched_ctx_id] == tree);
+	trees[tree->sched_ctx_id] = NULL;
 	if(tree->root)
 		starpu_sched_component_destroy_rec(tree->root);
 	starpu_bitmap_destroy(tree->workers);
@@ -405,6 +411,10 @@ void starpu_sched_tree_destroy(struct starpu_sched_tree * tree)
 	free(tree);
 }
 
+struct starpu_sched_tree * starpu_get_tree(unsigned sched_ctx_id)
+{
+	return trees[sched_ctx_id];
+}
 
 
 /******************************************************************************
@@ -553,10 +563,11 @@ static void take_component_and_does_nothing(struct starpu_sched_component * comp
 {
 }
 
-struct starpu_sched_component * starpu_sched_component_create(void)
+struct starpu_sched_component * starpu_sched_component_create(struct starpu_sched_tree *tree)
 {
 	struct starpu_sched_component * component = malloc(sizeof(*component));
 	memset(component,0,sizeof(*component));
+	component->tree = tree;
 	component->workers = starpu_bitmap_create();
 	component->workers_in_ctx = starpu_bitmap_create();
 	component->add_child = starpu_sched_component_add_child;

src/sched_policies/component_work_stealing.c

@@ -242,7 +242,7 @@ int starpu_sched_tree_work_stealing_push_task(struct starpu_task *task)
 		return starpu_sched_tree_push_task(task);
 
 	unsigned sched_ctx_id = task->sched_ctx;
-	struct starpu_sched_component * component =starpu_sched_component_worker_get(workerid);
+	struct starpu_sched_component * component =starpu_sched_component_worker_get(sched_ctx_id, workerid);
 	while(component->parents[sched_ctx_id] != NULL)
 	{
 		component = component->parents[sched_ctx_id];
@@ -335,9 +335,9 @@ int starpu_sched_component_is_work_stealing(struct starpu_sched_component * comp
 	return component->push_task == push_task;
 }
 
-struct starpu_sched_component * starpu_sched_component_work_stealing_create(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)
 {
-	struct starpu_sched_component * component = starpu_sched_component_create();
+	struct starpu_sched_component * component = starpu_sched_component_create(tree);
 	struct _starpu_work_stealing_data * wsd = malloc(sizeof(*wsd));
 	memset(wsd, 0, sizeof(*wsd));
 	component->pull_task = pull_task;

src/sched_policies/component_worker.c

@@ -20,6 +20,7 @@
  */
 
 #include <starpu_sched_component.h>
+#include <sched_policies/sched_component.h>
 #include <core/workers.h>
 
 #include <float.h>
@@ -122,9 +123,7 @@ struct _starpu_worker_component_data
 };
 
 /* this array store worker components */
-static struct starpu_sched_component * _worker_components[STARPU_NMAXWORKERS];
-	
-struct starpu_sched_component * starpu_sched_component_worker_get(int workerid);
+static struct starpu_sched_component * _worker_components[STARPU_NMAX_SCHED_CTXS][STARPU_NMAXWORKERS];
 
 
 /******************************************************************************
@@ -150,11 +149,11 @@ static struct _starpu_task_grid * _starpu_task_grid_create(void)
 	return t;
 }
 
-static struct _starpu_worker_task_list * _worker_get_list(void)
+static struct _starpu_worker_task_list * _worker_get_list(unsigned sched_ctx_id)
 {
 	int workerid = starpu_worker_get_id();
 	STARPU_ASSERT(0 <= workerid && workerid < (int) starpu_worker_get_count());
-	struct _starpu_worker_component_data * d = starpu_sched_component_worker_get(workerid)->data;
+	struct _starpu_worker_component_data * d = starpu_sched_component_worker_get(sched_ctx_id, workerid)->data;
 	return d->list;
 }
 
@@ -317,16 +316,16 @@ struct _starpu_combined_worker * _starpu_sched_component_combined_worker_get_com
 	return data->combined_worker;
 }
 
-void _starpu_sched_component_lock_worker(int workerid)
+void _starpu_sched_component_lock_worker(unsigned sched_ctx_id, int workerid)
 {
 	STARPU_ASSERT(0 <= workerid && workerid < (int) starpu_worker_get_count());
-	struct _starpu_worker_component_data * data = starpu_sched_component_worker_get(workerid)->data;
+	struct _starpu_worker_component_data * data = starpu_sched_component_worker_get(sched_ctx_id, workerid)->data;
 	STARPU_PTHREAD_MUTEX_LOCK(&data->lock);
 }
-void _starpu_sched_component_unlock_worker(int workerid)
+void _starpu_sched_component_unlock_worker(unsigned sched_ctx_id, int workerid)
 {
 	STARPU_ASSERT(0 <= workerid && workerid < (int)starpu_worker_get_count());
-	struct _starpu_worker_component_data * data = starpu_sched_component_worker_get(workerid)->data;
+	struct _starpu_worker_component_data * data = starpu_sched_component_worker_get(sched_ctx_id, workerid)->data;
 	STARPU_PTHREAD_MUTEX_UNLOCK(&data->lock);
 }
 
@@ -342,24 +341,24 @@ void _starpu_sched_component_unlock_worker(int workerid)
  * self-defined can_push calls to allow can_pull calls to take those mutexes while the 
  * current worker is pushing tasks on other workers (or itself). 
  */
-static void _starpu_sched_component_worker_lock_scheduling(void)
+static void _starpu_sched_component_worker_lock_scheduling(unsigned sched_ctx_id)
 {
 	int workerid = starpu_worker_get_id();
 	starpu_pthread_mutex_t *sched_mutex;
 	starpu_pthread_cond_t *sched_cond;
 	starpu_worker_get_sched_condition(workerid, &sched_mutex, &sched_cond);
-	_starpu_sched_component_lock_worker(workerid);	
+	_starpu_sched_component_lock_worker(sched_ctx_id, workerid);	
 	STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
 }
 
-static void _starpu_sched_component_worker_unlock_scheduling(void)
+static void _starpu_sched_component_worker_unlock_scheduling(unsigned sched_ctx_id)
 {
 	int workerid = starpu_worker_get_id();
 	starpu_pthread_mutex_t *sched_mutex;
 	starpu_pthread_cond_t *sched_cond;
 	starpu_worker_get_sched_condition(workerid, &sched_mutex, &sched_cond);
 	STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
-	_starpu_sched_component_unlock_worker(workerid);	
+	_starpu_sched_component_unlock_worker(sched_ctx_id, workerid);	
 }
 
 static void _starpu_sched_component_worker_set_sleep_status(struct starpu_sched_component * worker_component)
@@ -406,7 +405,7 @@ static int _worker_consistant(struct starpu_sched_component * component)
 	int is_a_worker = 0;
 	int i;
 	for(i = 0; i<STARPU_NMAXWORKERS; i++)
-		if(_worker_components[i] == component)
+		if(_worker_components[component->tree->sched_ctx_id][i] == component)
 			is_a_worker = 1;
 	if(!is_a_worker)
 		return 0;
@@ -414,7 +413,7 @@ static int _worker_consistant(struct starpu_sched_component * component)
 	if(data->worker)
 	{
 		int id = data->worker->workerid;
-		return  (_worker_components[id] == component)
+		return  (_worker_components[component->tree->sched_ctx_id][id] == component)
 			&&  component->nchildren == 0;
 	}
 	return 1;
@@ -433,13 +432,13 @@ static void simple_worker_can_pull(struct starpu_sched_component * worker_compon
 {
 	(void) worker_component;
 	struct _starpu_worker * w = _starpu_sched_component_worker_get_worker(worker_component);
-	_starpu_sched_component_lock_worker(w->workerid);
+	_starpu_sched_component_lock_worker(worker_component->tree->sched_ctx_id, w->workerid);
 	if(_starpu_sched_component_worker_is_reset_status(worker_component))
 		_starpu_sched_component_worker_set_changed_status(worker_component);
 
 	if(w->workerid == starpu_worker_get_id())
 	{
-		_starpu_sched_component_unlock_worker(w->workerid);
+		_starpu_sched_component_unlock_worker(worker_component->tree->sched_ctx_id, w->workerid);
 		return;
 	}
 	if(_starpu_sched_component_worker_is_sleeping_status(worker_component))
@@ -447,11 +446,11 @@ static void simple_worker_can_pull(struct starpu_sched_component * worker_compon
 		starpu_pthread_mutex_t *sched_mutex;
 		starpu_pthread_cond_t *sched_cond;
 		starpu_worker_get_sched_condition(w->workerid, &sched_mutex, &sched_cond);
-		_starpu_sched_component_unlock_worker(w->workerid);
+		_starpu_sched_component_unlock_worker(worker_component->tree->sched_ctx_id, w->workerid);
 		starpu_wakeup_worker(w->workerid, sched_cond, sched_mutex);
 	}
 	else
-		_starpu_sched_component_unlock_worker(w->workerid);
+		_starpu_sched_component_unlock_worker(worker_component->tree->sched_ctx_id, w->workerid);
 }
 
 static int simple_worker_push_task(struct starpu_sched_component * component, struct starpu_task *task)
@@ -491,7 +490,7 @@ static struct starpu_task * simple_worker_pull_task(struct starpu_sched_componen
 		starpu_push_task_end(task);
 		return task;
 	}
-	_starpu_sched_component_lock_worker(workerid);	
+	_starpu_sched_component_lock_worker(component->tree->sched_ctx_id, workerid);	
 	int i;
 	do {
 		_starpu_sched_component_worker_reset_status(component);
@@ -501,27 +500,26 @@ static struct starpu_task * simple_worker_pull_task(struct starpu_sched_componen
 				continue;
 			else
 			{
-				_starpu_sched_component_worker_unlock_scheduling();
+				_starpu_sched_component_worker_unlock_scheduling(component->tree->sched_ctx_id);
 				task = component->parents[i]->pull_task(component->parents[i]);
-				_starpu_sched_component_worker_lock_scheduling();
+				_starpu_sched_component_worker_lock_scheduling(component->tree->sched_ctx_id);
 				if(task)
 					break;
 			}
 		}
 	} while((!task) && _starpu_sched_component_worker_is_changed_status(component));
 	_starpu_sched_component_worker_set_sleep_status(component);
-	_starpu_sched_component_unlock_worker(workerid);	
+	_starpu_sched_component_unlock_worker(component->tree->sched_ctx_id, workerid);	
 	if(!task)
 		return NULL;
 	if(task->cl->type == STARPU_SPMD)
 	{
-		int workerid = starpu_worker_get_id();
 		if(!starpu_worker_is_combined_worker(workerid))
 		{
 			starpu_push_task_end(task);
 			return task;
 		}
-		struct starpu_sched_component * combined_worker_component = starpu_sched_component_worker_get(workerid);
+		struct starpu_sched_component * combined_worker_component = starpu_sched_component_worker_get(component->tree->sched_ctx_id, workerid);
 		(void)combined_worker_component->push_task(combined_worker_component, task);
 		/* we have pushed a task in queue, so can make a recursive call */
 		return simple_worker_pull_task(component);
@@ -568,27 +566,28 @@ static void _worker_component_deinit_data(struct starpu_sched_component * compon
 	_starpu_worker_task_list_destroy(d->list);
 	if(starpu_sched_component_is_simple_worker(component))
 		STARPU_PTHREAD_MUTEX_DESTROY(&d->lock);
-	int i;
+	int i, j;
+	for(j = 0; j < STARPU_NMAX_SCHED_CTXS; j++)
 	for(i = 0; i < STARPU_NMAXWORKERS; i++)
-		if(_worker_components[i] == component)
+		if(_worker_components[j][i] == component)
 		{
-			_worker_components[i] = NULL;
+			_worker_components[j][i] = NULL;
 			break;
 		}
 	free(d);
 }
 
-static struct starpu_sched_component * starpu_sched_component_worker_create(int workerid)
+static struct starpu_sched_component * starpu_sched_component_worker_create(struct starpu_sched_tree *tree, int workerid)
 {
 	STARPU_ASSERT(0 <=  workerid && workerid < (int) starpu_worker_get_count());
 
-	if(_worker_components[workerid])
-		return _worker_components[workerid];
+	if(_worker_components[tree->sched_ctx_id][workerid])
+		return _worker_components[tree->sched_ctx_id][workerid];
 
 	struct _starpu_worker * worker = _starpu_get_worker_struct(workerid);
 	if(worker == NULL)
 		return NULL;
-	struct starpu_sched_component * component = starpu_sched_component_create();
+	struct starpu_sched_component * component = starpu_sched_component_create(tree);
 	struct _starpu_worker_component_data * data = malloc(sizeof(*data));
 	memset(data, 0, sizeof(*data));
 
@@ -606,7 +605,7 @@ static struct starpu_sched_component * starpu_sched_component_worker_create(int
 	component->deinit_data = _worker_component_deinit_data;
 	starpu_bitmap_set(component->workers, workerid);
 	starpu_bitmap_or(component->workers_in_ctx, component->workers);
-	_worker_components[workerid] = component;
+	_worker_components[tree->sched_ctx_id][workerid] = component;
 
 	/*
 #ifdef STARPU_HAVE_HWLOC
@@ -641,7 +640,7 @@ static void combined_worker_can_pull(struct starpu_sched_component * component)
 		if(i == workerid)
 			continue;
 		int worker = data->combined_worker->combined_workerid[i];
-		_starpu_sched_component_lock_worker(worker);
+		_starpu_sched_component_lock_worker(component->tree->sched_ctx_id, worker);
 		if(_starpu_sched_component_worker_is_sleeping_status(component))
 		{
 			starpu_pthread_mutex_t *sched_mutex;
@@ -652,7 +651,7 @@ static void combined_worker_can_pull(struct starpu_sched_component * component)
 		if(_starpu_sched_component_worker_is_reset_status(component))
 			_starpu_sched_component_worker_set_changed_status(component);
 
-		_starpu_sched_component_unlock_worker(worker);
+		_starpu_sched_component_unlock_worker(component->tree->sched_ctx_id, worker);
 	}
 }
 
@@ -685,7 +684,7 @@ static int combined_worker_push_task(struct starpu_sched_component * component,
 	i = 0;
 	do
 	{
-		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(combined_worker->combined_workerid[i]);
+		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(component->tree->sched_ctx_id, combined_worker->combined_workerid[i]);
 		struct _starpu_worker_component_data * worker_data = worker_component->data;
 		struct _starpu_worker_task_list * list = worker_data->list;
 		STARPU_PTHREAD_MUTEX_LOCK(&list->mutex);
@@ -715,7 +714,7 @@ static int combined_worker_push_task(struct starpu_sched_component * component,
 		/* wake up all other workers of combined worker */
 		for(i = 0; i < combined_worker->worker_size; i++)
 		{
-			struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(combined_worker->combined_workerid[i]);
+			struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(component->tree->sched_ctx_id, combined_worker->combined_workerid[i]);
 			simple_worker_can_pull(worker_component);
 		}
 
@@ -736,7 +735,7 @@ static double combined_worker_estimated_end(struct starpu_sched_component * comp
 	int i;
 	for(i = 0; i < combined_worker->worker_size; i++)
 	{
-		data = _worker_components[combined_worker->combined_workerid[i]]->data;
+		data = _worker_components[component->tree->sched_ctx_id][combined_worker->combined_workerid[i]]->data;
 		STARPU_PTHREAD_MUTEX_LOCK(&data->list->mutex);
 		double tmp = data->list->exp_end;
 		STARPU_PTHREAD_MUTEX_UNLOCK(&data->list->mutex);
@@ -753,23 +752,23 @@ static double combined_worker_estimated_load(struct starpu_sched_component * com
 	int i;
 	for(i = 0; i < c->worker_size; i++)
 	{
-		struct starpu_sched_component * n = starpu_sched_component_worker_get(c->combined_workerid[i]);
+		struct starpu_sched_component * n = starpu_sched_component_worker_get(component->tree->sched_ctx_id, c->combined_workerid[i]);
 		load += n->estimated_load(n);
 	}
 	return load;
 }
 
-static struct starpu_sched_component  * starpu_sched_component_combined_worker_create(int workerid)
+static struct starpu_sched_component  * starpu_sched_component_combined_worker_create(struct starpu_sched_tree *tree, int workerid)
 {
 	STARPU_ASSERT(0 <= workerid && workerid <  STARPU_NMAXWORKERS);
 
-	if(_worker_components[workerid])
-		return _worker_components[workerid];
+	if(_worker_components[tree->sched_ctx_id][workerid])
+		return _worker_components[tree->sched_ctx_id][workerid];
 
 	struct _starpu_combined_worker * combined_worker = _starpu_get_combined_worker_struct(workerid);
 	if(combined_worker == NULL)
 		return NULL;
-	struct starpu_sched_component * component = starpu_sched_component_create();
+	struct starpu_sched_component * component = starpu_sched_component_create(tree);
 	struct _starpu_worker_component_data * data = malloc(sizeof(*data));
 	memset(data, 0, sizeof(*data));
 	data->combined_worker = combined_worker;
@@ -784,7 +783,7 @@ static struct starpu_sched_component  * starpu_sched_component_combined_worker_c
 	component->deinit_data = _worker_component_deinit_data;
 	starpu_bitmap_set(component->workers, workerid);
 	starpu_bitmap_or(component->workers_in_ctx, component->workers);
-	_worker_components[workerid] = component;
+	_worker_components[tree->sched_ctx_id][workerid] = component;
 
 #ifdef STARPU_HAVE_HWLOC
 	struct _starpu_machine_config *config = _starpu_get_machine_config();
@@ -804,25 +803,26 @@ static struct starpu_sched_component  * starpu_sched_component_combined_worker_c
 
 
 
-void _starpu_sched_component_lock_all_workers(void)
+void _starpu_sched_component_lock_all_workers(unsigned sched_ctx_id)
 {
 	unsigned i;
 	for(i = 0; i < starpu_worker_get_count(); i++)
-		_starpu_sched_component_lock_worker(i);
+		_starpu_sched_component_lock_worker(sched_ctx_id, i);
 }
-void _starpu_sched_component_unlock_all_workers(void)
+void _starpu_sched_component_unlock_all_workers(unsigned sched_ctx_id)
 {
 	unsigned i;
 	for(i = 0; i < starpu_worker_get_count(); i++)
-		_starpu_sched_component_unlock_worker(i);
+		_starpu_sched_component_unlock_worker(sched_ctx_id, i);
 }
 
 void _starpu_sched_component_workers_destroy(void)
 {
-	int i;
+	int i, j;
+	for(j = 0; j < STARPU_NMAX_SCHED_CTXS; j++)
 	for(i = 0; i < STARPU_NMAXWORKERS; i++)
-		if (_worker_components[i])
-			starpu_sched_component_destroy(_worker_components[i]);
+		if (_worker_components[j][i])
+			starpu_sched_component_destroy(_worker_components[j][i]);
 }
 
 int starpu_sched_component_worker_get_workerid(struct starpu_sched_component * worker_component)
@@ -838,7 +838,8 @@ void starpu_sched_component_worker_pre_exec_hook(struct starpu_task * task)
 {
 	if(!isnan(task->predicted))
 	{
-		struct _starpu_worker_task_list * list = _worker_get_list();
+		unsigned sched_ctx_id = task->sched_ctx;
+		struct _starpu_worker_task_list * list = _worker_get_list(sched_ctx_id);
 		STARPU_PTHREAD_MUTEX_LOCK(&list->mutex);
 
 		list->exp_start = starpu_timing_now() + task->predicted;
@@ -858,7 +859,8 @@ void starpu_sched_component_worker_post_exec_hook(struct starpu_task * task)
 {
 	if(task->execute_on_a_specific_worker)
 		return;
-	struct _starpu_worker_task_list * list = _worker_get_list();
+	unsigned sched_ctx_id = task->sched_ctx;
+	struct _starpu_worker_task_list * list = _worker_get_list(sched_ctx_id);
 	STARPU_PTHREAD_MUTEX_LOCK(&list->mutex);
 	list->exp_start = starpu_timing_now();
 	list->exp_end = list->exp_start + list->exp_len;
@@ -882,20 +884,20 @@ int starpu_sched_component_is_worker(struct starpu_sched_component * component)
 
 /* As Worker Components' creating functions are protected, this function allows
  * the user to get a Worker Component from a worker id */
-struct starpu_sched_component * starpu_sched_component_worker_get(int workerid)
+struct starpu_sched_component * starpu_sched_component_worker_get(unsigned sched_ctx, int workerid)
 {
 	STARPU_ASSERT(workerid >= 0 && workerid < STARPU_NMAXWORKERS);
 	/* we may need to take a mutex here */
-	if(_worker_components[workerid])
-		return _worker_components[workerid];
+	if(_worker_components[sched_ctx][workerid])
+		return _worker_components[sched_ctx][workerid];
 	else
 	{
 		struct starpu_sched_component * component;
 		if(workerid < (int) starpu_worker_get_count())
-			component = starpu_sched_component_worker_create(workerid);
+			component = starpu_sched_component_worker_create(starpu_get_tree(sched_ctx), workerid);
 		else
-			component = starpu_sched_component_combined_worker_create(workerid);
-		_worker_components[workerid] = component;
+			component = starpu_sched_component_combined_worker_create(starpu_get_tree(sched_ctx), workerid);
+		_worker_components[sched_ctx][workerid] = component;
 		return component;
 	}
 }

src/sched_policies/modular_eager.c

@@ -24,15 +24,15 @@ static void initialize_eager_center_policy(unsigned sched_ctx_id)
 
 	starpu_sched_ctx_create_worker_collection(sched_ctx_id, STARPU_WORKER_LIST);
 	struct starpu_sched_tree *t = starpu_sched_tree_create(sched_ctx_id);
- 	t->root = starpu_sched_component_fifo_create(NULL);
-	struct starpu_sched_component * eager_component = starpu_sched_component_eager_create(NULL);
+ 	t->root = starpu_sched_component_fifo_create(t, NULL);
+	struct starpu_sched_component * eager_component = starpu_sched_component_eager_create(t, NULL);
 	t->root->add_child(t->root, eager_component);
 	eager_component->add_parent(eager_component, t->root);
 
 	unsigned i;
 	for(i = 0; i < starpu_worker_get_count() + starpu_combined_worker_get_count(); i++)
 	{
-		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(i);
+		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(sched_ctx_id, i);
 		STARPU_ASSERT(worker_component);
 
 		eager_component->add_child(eager_component, worker_component);

src/sched_policies/modular_eager_prefetching.c

@@ -38,8 +38,8 @@ static void initialize_eager_prefetching_center_policy(unsigned sched_ctx_id)
 
 	starpu_sched_ctx_create_worker_collection(sched_ctx_id, STARPU_WORKER_LIST);
 	struct starpu_sched_tree *t = starpu_sched_tree_create(sched_ctx_id);
- 	t->root = starpu_sched_component_fifo_create(NULL);
-	struct starpu_sched_component * eager_component = starpu_sched_component_eager_create(NULL);
+ 	t->root = starpu_sched_component_fifo_create(t, NULL);
+	struct starpu_sched_component * eager_component = starpu_sched_component_eager_create(t, NULL);
 	t->root->add_child(t->root, eager_component);
 	eager_component->add_parent(eager_component, t->root);
 
@@ -52,10 +52,10 @@ static void initialize_eager_prefetching_center_policy(unsigned sched_ctx_id)
 	unsigned i;
 	for(i = 0; i < starpu_worker_get_count() + starpu_combined_worker_get_count(); i++)
 	{
-		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(i);
+		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(sched_ctx_id, i);
 		STARPU_ASSERT(worker_component);
 
-		struct starpu_sched_component * fifo_component = starpu_sched_component_fifo_create(&fifo_data);
+		struct starpu_sched_component * fifo_component = starpu_sched_component_fifo_create(t, &fifo_data);
 		fifo_component->add_child(fifo_component, worker_component);
 		worker_component->add_parent(worker_component, fifo_component);
 

src/sched_policies/modular_heft.c

@@ -81,12 +81,12 @@ static void initialize_heft_center_policy(unsigned sched_ctx_id)
  */
 	struct starpu_sched_tree * t = starpu_sched_tree_create(sched_ctx_id);
 
-	struct starpu_sched_component * window_component = starpu_sched_component_prio_create(NULL);
+	struct starpu_sched_component * window_component = starpu_sched_component_prio_create(t, NULL);
 	t->root = window_component;
 
-	struct starpu_sched_component * perfmodel_component = starpu_sched_component_mct_create(NULL);
-	struct starpu_sched_component * no_perfmodel_component = starpu_sched_component_eager_create(NULL);
-	struct starpu_sched_component * calibrator_component = starpu_sched_component_eager_calibration_create(NULL);
+	struct starpu_sched_component * perfmodel_component = starpu_sched_component_mct_create(t, NULL);
+	struct starpu_sched_component * no_perfmodel_component = starpu_sched_component_eager_create(t, NULL);
+	struct starpu_sched_component * calibrator_component = starpu_sched_component_eager_calibration_create(t, NULL);
 	
 	struct starpu_perfmodel_select_data perfmodel_select_data =
 		{
@@ -95,7 +95,7 @@ static void initialize_heft_center_policy(unsigned sched_ctx_id)
 			.perfmodel_component = perfmodel_component,
 		};
 
-	struct starpu_sched_component * perfmodel_select_component = starpu_sched_component_perfmodel_select_create(&perfmodel_select_data);
+	struct starpu_sched_component * perfmodel_select_component = starpu_sched_component_perfmodel_select_create(t, &perfmodel_select_data);
 	window_component->add_child(window_component, perfmodel_select_component);
 	perfmodel_select_component->add_parent(perfmodel_select_component, window_component);
 
@@ -115,14 +115,14 @@ static void initialize_heft_center_policy(unsigned sched_ctx_id)
 	unsigned i;
 	for(i = 0; i < starpu_worker_get_count() + starpu_combined_worker_get_count(); i++)
 	{
-		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(i);
+		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(sched_ctx_id, i);
 		STARPU_ASSERT(worker_component);
 
-		struct starpu_sched_component * prio_component = starpu_sched_component_prio_create(&prio_data);
+		struct starpu_sched_component * prio_component = starpu_sched_component_prio_create(t, &prio_data);
 		prio_component->add_child(prio_component, worker_component);
 		worker_component->add_parent(worker_component, prio_component);
 
-		struct starpu_sched_component * impl_component = starpu_sched_component_best_implementation_create(NULL);
+		struct starpu_sched_component * impl_component = starpu_sched_component_best_implementation_create(t, NULL);
 		impl_component->add_child(impl_component, prio_component);
 		prio_component->add_parent(prio_component, impl_component);
 

src/sched_policies/modular_heft2.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2013  Université de Bordeaux 1
+ * Copyright (C) 2013-2014  Université de Bordeaux 1
  * Copyright (C) 2013  INRIA
  * Copyright (C) 2013  Simon Archipoff
  *
@@ -48,9 +48,9 @@ static void initialize_heft2_center_policy(unsigned sched_ctx_id)
 
 	struct starpu_sched_tree * t = starpu_sched_tree_create(sched_ctx_id);
 
-	struct starpu_sched_component * perfmodel_component = starpu_sched_component_heft_create(NULL);
-	struct starpu_sched_component * no_perfmodel_component = starpu_sched_component_eager_create(NULL);
-	struct starpu_sched_component * calibrator_component = starpu_sched_component_eager_create(NULL);
+	struct starpu_sched_component * perfmodel_component = starpu_sched_component_heft_create(t, NULL);
+	struct starpu_sched_component * no_perfmodel_component = starpu_sched_component_eager_create(t, NULL);
+	struct starpu_sched_component * calibrator_component = starpu_sched_component_eager_create(t, NULL);
 	
 	struct starpu_perfmodel_select_data perfmodel_select_data =
 		{
@@ -59,10 +59,10 @@ static void initialize_heft2_center_policy(unsigned sched_ctx_id)
 			.perfmodel_component = perfmodel_component,
 		};
 
-	struct starpu_sched_component * window_component = starpu_sched_component_prio_create(NULL);
+	struct starpu_sched_component * window_component = starpu_sched_component_prio_create(t, NULL);
 	t->root = window_component;
 
-	struct starpu_sched_component * perfmodel_select_component = starpu_sched_component_perfmodel_select_create(&perfmodel_select_data);
+	struct starpu_sched_component * perfmodel_select_component = starpu_sched_component_perfmodel_select_create(t, &perfmodel_select_data);
 	window_component->add_child(window_component, perfmodel_select_component);
 	perfmodel_select_component->add_parent(perfmodel_select_component, window_component);
 
@@ -82,14 +82,14 @@ static void initialize_heft2_center_policy(unsigned sched_ctx_id)
 	unsigned i;
 	for(i = 0; i < starpu_worker_get_count() + starpu_combined_worker_get_count(); i++)
 	{
-		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(i);
+		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(sched_ctx_id, i);
 		STARPU_ASSERT(worker_component);
 
-		struct starpu_sched_component * prio_component = starpu_sched_component_prio_create(&prio_data);
+		struct starpu_sched_component * prio_component = starpu_sched_component_prio_create(t, &prio_data);
 		prio_component->add_child(prio_component, worker_component);
 		worker_component->add_parent(worker_component, prio_component);
 
-		struct starpu_sched_component * impl_component = starpu_sched_component_best_implementation_create(NULL);
+		struct starpu_sched_component * impl_component = starpu_sched_component_best_implementation_create(t, NULL);
 		impl_component->add_child(impl_component, prio_component);
 		prio_component->add_parent(prio_component, impl_component);
 

src/sched_policies/modular_prio.c

@@ -21,15 +21,15 @@ static void initialize_prio_center_policy(unsigned sched_ctx_id)
 {
 	starpu_sched_ctx_create_worker_collection(sched_ctx_id, STARPU_WORKER_LIST);
 	struct starpu_sched_tree *t = starpu_sched_tree_create(sched_ctx_id);
- 	t->root = starpu_sched_component_prio_create(NULL);
-	struct starpu_sched_component * eager_component = starpu_sched_component_eager_create(NULL);
+ 	t->root = starpu_sched_component_prio_create(t, NULL);
+	struct starpu_sched_component * eager_component = starpu_sched_component_eager_create(t, NULL);
 	t->root->add_child(t->root, eager_component);
 	eager_component->add_parent(eager_component, t->root);
 
 	unsigned i;
 	for(i = 0; i < starpu_worker_get_count() + starpu_combined_worker_get_count(); i++)
 	{
-		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(i);
+		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(sched_ctx_id, i);
 		STARPU_ASSERT(worker_component);
 
 		eager_component->add_child(eager_component, worker_component);

src/sched_policies/modular_prio_prefetching.c

@@ -35,8 +35,8 @@ static void initialize_prio_prefetching_center_policy(unsigned sched_ctx_id)
 
 	starpu_sched_ctx_create_worker_collection(sched_ctx_id, STARPU_WORKER_LIST);
 	struct starpu_sched_tree *t = starpu_sched_tree_create(sched_ctx_id);
- 	t->root = starpu_sched_component_prio_create(NULL);
-	struct starpu_sched_component * eager_component = starpu_sched_component_eager_create(NULL);
+ 	t->root = starpu_sched_component_prio_create(t, NULL);
+	struct starpu_sched_component * eager_component = starpu_sched_component_eager_create(t, NULL);
 	t->root->add_child(t->root, eager_component);
 	eager_component->add_parent(eager_component, t->root);
 
@@ -49,10 +49,10 @@ static void initialize_prio_prefetching_center_policy(unsigned sched_ctx_id)
 	unsigned i;
 	for(i = 0; i < starpu_worker_get_count() + starpu_combined_worker_get_count(); i++)
 	{
-		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(i);
+		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(sched_ctx_id, i);
 		STARPU_ASSERT(worker_component);
 
-		struct starpu_sched_component * prio_component = starpu_sched_component_prio_create(&prio_data);
+		struct starpu_sched_component * prio_component = starpu_sched_component_prio_create(t, &prio_data);
 		prio_component->add_child(prio_component, worker_component);
 		worker_component->add_parent(worker_component, prio_component);
 

src/sched_policies/modular_random.c

@@ -24,15 +24,15 @@ static void initialize_random_fifo_center_policy(unsigned sched_ctx_id)
 {
 	starpu_sched_ctx_create_worker_collection(sched_ctx_id, STARPU_WORKER_LIST);
 	struct starpu_sched_tree *t = starpu_sched_tree_create(sched_ctx_id);
- 	t->root = starpu_sched_component_fifo_create(NULL);
-	struct starpu_sched_component * random_component = starpu_sched_component_random_create(NULL);
+ 	t->root = starpu_sched_component_fifo_create(t, NULL);
+	struct starpu_sched_component * random_component = starpu_sched_component_random_create(t, NULL);
 	t->root->add_child(t->root, random_component);
 	random_component->add_parent(random_component, t->root);
 
 	unsigned i;
 	for(i = 0; i < starpu_worker_get_count() + starpu_combined_worker_get_count(); i++)
 	{
-		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(i);
+		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(sched_ctx_id, i);
 		STARPU_ASSERT(worker_component);
 
 		random_component->add_child(random_component, worker_component);
@@ -70,15 +70,15 @@ static void initialize_random_prio_center_policy(unsigned sched_ctx_id)
 {
 	starpu_sched_ctx_create_worker_collection(sched_ctx_id, STARPU_WORKER_LIST);
 	struct starpu_sched_tree *t = starpu_sched_tree_create(sched_ctx_id);
- 	t->root = starpu_sched_component_prio_create(NULL);
-	struct starpu_sched_component * random_component = starpu_sched_component_random_create(NULL);
+ 	t->root = starpu_sched_component_prio_create(t, NULL);
+	struct starpu_sched_component * random_component = starpu_sched_component_random_create(t, NULL);
 	t->root->add_child(t->root, random_component);
 	random_component->add_parent(random_component, t->root);
 
 	unsigned i;
 	for(i = 0; i < starpu_worker_get_count() + starpu_combined_worker_get_count(); i++)
 	{
-		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(i);
+		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(sched_ctx_id, i);
 		STARPU_ASSERT(worker_component);
 
 		random_component->add_child(random_component, worker_component);

src/sched_policies/modular_random_prefetching.c

@@ -38,8 +38,8 @@ static void initialize_random_fifo_prefetching_center_policy(unsigned sched_ctx_
 
 	starpu_sched_ctx_create_worker_collection(sched_ctx_id, STARPU_WORKER_LIST);
 	struct starpu_sched_tree *t = starpu_sched_tree_create(sched_ctx_id);
- 	t->root = starpu_sched_component_fifo_create(NULL);
-	struct starpu_sched_component * random_component = starpu_sched_component_random_create(NULL);
+ 	t->root = starpu_sched_component_fifo_create(t, NULL);
+	struct starpu_sched_component * random_component = starpu_sched_component_random_create(t, NULL);
 	t->root->add_child(t->root, random_component);
 	random_component->add_parent(random_component, t->root);
 
@@ -52,10 +52,10 @@ static void initialize_random_fifo_prefetching_center_policy(unsigned sched_ctx_
 	unsigned i;
 	for(i = 0; i < starpu_worker_get_count() + starpu_combined_worker_get_count(); i++)
 	{
-		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(i);
+		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(sched_ctx_id, i);
 		STARPU_ASSERT(worker_component);
 
-		struct starpu_sched_component * fifo_component = starpu_sched_component_fifo_create(&fifo_data);
+		struct starpu_sched_component * fifo_component = starpu_sched_component_fifo_create(t, &fifo_data);
 		fifo_component->add_child(fifo_component, worker_component);
 		worker_component->add_parent(worker_component, fifo_component);
 
@@ -105,8 +105,8 @@ static void initialize_random_prio_prefetching_center_policy(unsigned sched_ctx_
 
 	starpu_sched_ctx_create_worker_collection(sched_ctx_id, STARPU_WORKER_LIST);
 	struct starpu_sched_tree *t = starpu_sched_tree_create(sched_ctx_id);
- 	t->root = starpu_sched_component_prio_create(NULL);
-	struct starpu_sched_component * random_component = starpu_sched_component_random_create(NULL);
+ 	t->root = starpu_sched_component_prio_create(t, NULL);
+	struct starpu_sched_component * random_component = starpu_sched_component_random_create(t, NULL);
 	t->root->add_child(t->root, random_component);
 	random_component->add_parent(random_component, t->root);
 
@@ -119,10 +119,10 @@ static void initialize_random_prio_prefetching_center_policy(unsigned sched_ctx_
 	unsigned i;
 	for(i = 0; i < starpu_worker_get_count() + starpu_combined_worker_get_count(); i++)
 	{
-		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(i);
+		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(sched_ctx_id, i);
 		STARPU_ASSERT(worker_component);
 
-		struct starpu_sched_component * prio_component = starpu_sched_component_prio_create(&prio_data);
+		struct starpu_sched_component * prio_component = starpu_sched_component_prio_create(t, &prio_data);
 		prio_component->add_child(prio_component, worker_component);
 		worker_component->add_parent(worker_component, prio_component);
 

src/sched_policies/modular_ws.c

@@ -23,11 +23,11 @@ static void initialize_ws_center_policy(unsigned sched_ctx_id)
 {
 	starpu_sched_ctx_create_worker_collection(sched_ctx_id, STARPU_WORKER_LIST);
 	struct starpu_sched_tree *t = starpu_sched_tree_create(sched_ctx_id);
- 	t->root = starpu_sched_component_work_stealing_create(NULL);
+ 	t->root = starpu_sched_component_work_stealing_create(t, NULL);
 	unsigned i;
 	for(i = 0; i < starpu_worker_get_count() + starpu_combined_worker_get_count(); i++)
 	{
-		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(i);
+		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(sched_ctx_id, i);
 		STARPU_ASSERT(worker_component);
 
 		t->root->add_child(t->root, worker_component);

src/sched_policies/sched_component.h

@@ -21,10 +21,10 @@
 
 
 /* lock and unlock drivers for modifying schedulers */
-void _starpu_sched_component_lock_all_workers(void);
-void _starpu_sched_component_unlock_all_workers(void);
-void _starpu_sched_component_lock_worker(int workerid);
-void _starpu_sched_component_unlock_worker(int workerid);
+void _starpu_sched_component_lock_all_workers(unsigned sched_ctx_id);
+void _starpu_sched_component_unlock_all_workers(unsigned sched_ctx_id);
+void _starpu_sched_component_lock_worker(unsigned sched_ctx_id, int workerid);
+void _starpu_sched_component_unlock_worker(unsigned sched_ctx_id, int workerid);
 
 void _starpu_sched_component_workers_destroy(void);
 

src/sched_policies/scheduler_maker.c

@@ -53,7 +53,7 @@ static void add_component(struct sched_component_list *list, struct starpu_sched
 	list->size++;
 }
 /* this is the function that actualy built the scheduler, but without workers */
-static struct sched_component_list helper_make_scheduler(hwloc_obj_t obj, struct starpu_sched_specs specs, unsigned sched_ctx_id)
+static struct sched_component_list helper_make_scheduler(struct starpu_sched_tree *tree, hwloc_obj_t obj, struct starpu_sched_specs specs, unsigned sched_ctx_id)
 {
 	STARPU_ASSERT(obj);
 
@@ -63,7 +63,7 @@ static struct sched_component_list helper_make_scheduler(hwloc_obj_t obj, struct
 #define CASE(ENUM,spec_member)						\
 		case ENUM:						\
 			if(specs.spec_member)				\
-				component = starpu_sched_component_composed_component_create(specs.spec_member); \
+				component = starpu_sched_component_composed_component_create(tree, specs.spec_member); \
 			break
 	switch(obj->type)
 	{
@@ -81,7 +81,7 @@ static struct sched_component_list helper_make_scheduler(hwloc_obj_t obj, struct
 	/* collect childs component's */
 	for(i = 0; i < obj->arity; i++)
 	{
-		struct sched_component_list lc = helper_make_scheduler(obj->children[i],specs, sched_ctx_id);
+		struct sched_component_list lc = helper_make_scheduler(tree, obj->children[i],specs, sched_ctx_id);
 		unsigned j;
 		for(j = 0; j < lc.size; j++)
 			add_component(&l, lc.arr[j]);
@@ -171,7 +171,7 @@ static struct starpu_sched_component * where_should_we_plug_this(struct starpu_s
 	}
 	if(obj->type == HWLOC_OBJ_NODE)
 	{	
-		struct starpu_sched_component * component = starpu_sched_component_composed_component_create(specs.hwloc_component_composed_sched_component);
+		struct starpu_sched_component * component = starpu_sched_component_composed_component_create(root->tree, specs.hwloc_component_composed_sched_component);
 		component->obj = obj;
 		parent->add_child(parent, component);
 		starpu_sched_component_add_parent(component, parent);
@@ -190,7 +190,7 @@ static void set_worker_leaf(struct starpu_sched_component * root, struct starpu_
 	STARPU_ASSERT(component);
 	if(recipe)
 	{
-		struct starpu_sched_component * tmp = starpu_sched_component_composed_component_create(recipe);
+		struct starpu_sched_component * tmp = starpu_sched_component_composed_component_create(root->tree, recipe);
 #ifdef STARPU_DEVEL
 #warning FIXME component->obj is set to worker_component->obj even for accelerators workers
 #endif
@@ -248,7 +248,7 @@ struct starpu_sched_tree * starpu_sched_component_make_scheduler(unsigned sched_
 	struct _starpu_machine_config *config = _starpu_get_machine_config();
 	hwloc_topology_t topology = config->topology.hwtopology;
 
-	struct sched_component_list list = helper_make_scheduler(hwloc_get_root_obj(topology), specs, sched_ctx_id);
+	struct sched_component_list list = helper_make_scheduler(tree, hwloc_get_root_obj(topology), specs, sched_ctx_id);
 	STARPU_ASSERT(list.size == 1);
 
 	tree->root = list.arr[0];
@@ -258,7 +258,7 @@ struct starpu_sched_tree * starpu_sched_component_make_scheduler(unsigned sched_
 	for(i = 0; i < starpu_worker_get_count(); i++)
 	{
 		struct _starpu_worker * worker = _starpu_get_worker_struct(i);
-		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(i);
+		struct starpu_sched_component * worker_component = starpu_sched_component_worker_get(sched_ctx_id, i);
 		STARPU_ASSERT(worker);
 		set_worker_leaf(tree->root,worker_component, sched_ctx_id, specs);
 	}