Renaming Hierarchical Scheduler ==> Modularized Scheduler

doc/doxygen/chapters/api/hierarchical_scheduler.doxy

@@ -1,7 +1,7 @@
-/*! \defgroup API_Hierarchical_Scheduler Hierarchical Scheduler Interface
+/*! \defgroup API_Modularized_Scheduler Modularized Scheduler Interface
 
 \struct starpu_sched_component
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 This structure represent a scheduler module.
 
 \var starpu_sched_component::push_task
@@ -45,7 +45,7 @@ This structure represent a scheduler module.
 	the hwloc object associated to scheduler module
 
 \enum starpu_sched_component_properties
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 flags for starpu_sched_component::properties
 \var STARPU_SCHED_component_HOMOGENEOUS
      indicate that all workers have the same starpu_worker_archtype
@@ -53,15 +53,15 @@ flags for starpu_sched_component::properties
      indicate that all workers have the same memory component
 
 \def STARPU_SCHED_component_IS_HOMOGENEOUS
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
      indicate if component is homogeneous
 \def STARPU_SCHED_component_IS_SINGLE_MEMORY_component
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
      indicate if all workers have the same memory component
 
 
 \struct starpu_sched_tree
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 The actual scheduler
 \var starpu_sched_tree::root
 	this is the entry module of the scheduler
@@ -73,7 +73,7 @@ The actual scheduler
 	the context id of the scheduler
 
 \fn struct starpu_sched_component * starpu_sched_component_create(void)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 allocate and initialize component field with defaults values :
 	.pop_task make recursive call on father
 	.estimated_load compute relative speedup and tasks in sub tree
@@ -85,101 +85,101 @@ The actual scheduler
 
 
 \fn void starpu_sched_component_destroy(struct starpu_sched_component * component)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 free data allocated by starpu_sched_component_create and call component->deinit_data(component)
 	 set to null the member starpu_sched_component::fathers[sched_ctx_id] of all child if its equal to \p component
 
 \fn void starpu_sched_component_set_father(struct starpu_sched_component * component, struct starpu_sched_component * father_component, unsigned sched_ctx_id)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 set component->fathers[sched_ctx_id] to father_component
 
 \fn void starpu_sched_component_add_child(struct starpu_sched_component* component, struct starpu_sched_component * child)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 add child to component->children and increment nchildren as well.
 	 and do not modify child->fathers
 	 \p child must not be already in starpu_sched_component::children of \p component
 
 \fn void starpu_sched_component_remove_child(struct starpu_sched_component * component, struct starpu_sched_component * child)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 remove child from component->children and decrements nchildren
 	 \p child must be in starpu_sched_component::child of \p component
 
 
 \fn int starpu_sched_component_can_execute_task(struct starpu_sched_component * component, struct starpu_task * task)
-\ingroup API_Hierarchical_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
 
 \fn int STARPU_WARN_UNUSED_RESULT starpu_sched_component_execute_preds(struct starpu_sched_component * component, struct starpu_task * task, double * length);
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 return a non null value if \p component can execute \p task.
 	 write the execution prediction length for the best implementation of the best worker available and write this at \p length address.
 	 this result is more relevant if starpu_sched_component::is_homogeneous is non null.
 	 if a worker need to be calibrated for an implementation, nan is set to \p length.
 
 \fn double starpu_sched_component_transfer_length(struct starpu_sched_component * component, struct starpu_task * task);
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 return the average time to transfer \p task data to underlying \p component workers.
 
 \fn struct starpu_sched_component * starpu_sched_component_worker_get(int workerid)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 return the struct starpu_sched_component corresponding to \p workerid. Undefined if \p workerid is not a valid workerid
 
 
 \fn int starpu_sched_component_is_worker(struct starpu_sched_component * component)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 return true iff \p component is a worker component
 \fn int starpu_sched_component_is_simple_worker(struct starpu_sched_component * component)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 return true iff \p component is a simple worker component
 \fn int starpu_sched_component_is_combined_worker(struct starpu_sched_component * component)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 return true iff \p component is a combined worker component
 \fn int starpu_sched_component_worker_get_workerid(struct starpu_sched_component * worker_component)
-\ingroup API_Hierarchical_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(void * arg STARPU_ATTRIBUTE_UNUSED)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 Return a struct starpu_sched_component with a fifo. A stable sort is performed according to tasks priorities.
 	 A push_task call on this component does not perform recursive calls, underlying components will have to call pop_task to get it.
 	 starpu_sched_component::estimated_end function compute the estimated length by dividing the sequential length by the number of underlying workers. Do not take into account tasks that are currently executed.
 
 \fn int starpu_sched_component_is_fifo(struct starpu_sched_component * component)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 return true iff \p component is a fifo component
 
 \fn struct starpu_sched_component * starpu_sched_component_work_stealing_create(void * arg STARPU_ATTRIBUTE_UNUSED)
-\ingroup API_Hierarchical_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)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 undefined if there is no work stealing component in the scheduler. If any, \p task is pushed in a default way if the caller is the application, and in the caller's fifo if its a worker.
 
 \fn int starpu_sched_component_is_work_stealing(struct starpu_sched_component * component)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 return true iff \p component is a work stealing component
 
 \fn struct starpu_sched_component * starpu_sched_component_random_create(void * arg STARPU_ATTRIBUTE_UNUSED)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 create a component that perform a random scheduling
 
 \fn int starpu_sched_component_is_random(struct starpu_sched_component *);
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 return true iff \p component is a random component
 
 \fn struct starpu_sched_component * starpu_sched_component_heft_create(struct starpu_heft_data * heft_data)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 this component perform a heft scheduling
 
 \fn int starpu_sched_component_is_heft(struct starpu_sched_component * component)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 return true iff \p component is a heft component
 
 \struct starpu_heft_data
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 starpu_sched_component_heft_create parameters
 \var starpu_heft_data::alpha
 	 coefficient applied to computation length
@@ -200,7 +200,7 @@ starpu_sched_component_heft_create parameters
 
 
 \fn struct starpu_sched_component * starpu_sched_component_best_implementation_create(void * arg STARPU_ATTRIBUTE_UNUSED);
-\ingroup API_Hierarchical_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.
@@ -209,120 +209,120 @@ starpu_sched_component_heft_create parameters
 
 
 \fn struct starpu_sched_tree * starpu_sched_tree_create(void)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 create a empty initialized starpu_sched_tree
 \fn void starpu_sched_tree_destroy(struct starpu_sched_tree * tree, unsigned sched_ctx_id)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 destroy tree and free all non shared component in it.
 \fn void starpu_sched_component_destroy_rec (struct starpu_sched_component *component, unsigned sched_ctx_id)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 recursively destroy non shared parts of a \p component 's tree
 
 
 \fn starpu_sched_component_available(struct starpu_sched_component * component)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 notify all component's underlying workers that a task is available to pop
 
 \fn int starpu_sched_tree_push_task(struct starpu_task * task)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 compatibility with starpu_sched_policy interface
 \fn struct starpu_task * starpu_sched_tree_pop_task(unsigned sched_ctx_id)
-\ingroup API_Hierarchical_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)
-\ingroup API_Hierarchical_Scheduler
+\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_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 compatibility with starpu_sched_policy interface
 \fn void starpu_sched_component_worker_pre_exec_hook(struct starpu_task * task)
-\ingroup API_Hierarchical_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)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 compatibility with starpu_sched_policy interface
 
 
 \fn void starpu_sched_tree_update_workers(struct starpu_sched_tree * t)
-\ingroup API_Hierarchical_Scheduler
+\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_Hierarchical_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;
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 implement a simple bitmap
 \fn struct starpu_bitmap * starpu_bitmap_create(void)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 create a empty starpu_bitmap
 \fn void starpu_bitmap_destroy(struct starpu_bitmap *)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 free a starpu_bitmap
 
 \fn void starpu_bitmap_set(struct starpu_bitmap * bitmap, int e)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 set bit \p e in \p bitmap
 \fn void starpu_bitmap_unset(struct starpu_bitmap * bitmap, int e)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 unset bit \p e in \p bitmap
 
 \fn void starpu_bitmap_unset_all(struct starpu_bitmap * bitmap)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 unset all bits in \b bitmap
 
 \fn int starpu_bitmap_get(struct starpu_bitmap * bitmap, int e);
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 return true iff bit \p e is set in \p bitmap
 
 \fn int starpu_bitmap_cardinal(struct starpu_bitmap * bitmap);
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 return the number of set bits in \p bitmap
 
 
 \fn int starpu_bitmap_first(struct starpu_bitmap * bitmap)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 return the position of the first set bit of \p bitmap, -1 if none
 \fn int starpu_bitmap_last(struct starpu_bitmap * bitmap)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 return the position of the last set bit of \p bitmap, -1 if none
 
 \fn int starpu_bitmap_next(struct starpu_bitmap *, int e)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 return the position of set bit right after \p e in \p bitmap, -1 if none
 
 
 \struct starpu_sched_component_composed_recipe;
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	parameters for starpu_sched_component_composed_component_create
 
 \fn struct starpu_sched_component_composed_recipe * starpu_sched_component_create_recipe(void)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 return an empty recipe for a composed component, it should not be used without modification
 
 
 \fn struct starpu_sched_component_composed_recipe * starpu_sched_component_create_recipe_singleton(struct starpu_sched_component *(*create_component)(void * arg), void * arg)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 return a recipe to build a composed component with a \p create_component
 
 \fn void starpu_sched_recipe_add_component(struct starpu_sched_component_composed_recipe * recipe, struct starpu_sched_component *(*create_component)(void * arg), void * arg)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 add \p create_component under all previous components in recipe
 
 \fn void starpu_destroy_composed_sched_component_recipe(struct starpu_sched_component_composed_recipe *)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 destroy composed_sched_component, this should be done after starpu_sched_component_composed_component_create was called
 
 \fn struct starpu_sched_component * starpu_sched_component_composed_component_create(struct starpu_sched_component_composed_recipe * recipe)
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 create a component that behave as all component of recipe where linked. Except that you cant use starpu_sched_component_is_foo function
 	 if recipe contain a single create_foo arg_foo pair, create_foo(arg_foo) is returned instead of a composed component
 
 
 \struct starpu_sched_specs
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 Define how build a scheduler according to topology. Each level (except for hwloc_machine_composed_sched_component) can be NULL, then
 	 the level is just skipped. Bugs everywhere, do not rely on.
 \var starpu_sched_specs::hwloc_machine_composed_sched_component
@@ -345,6 +345,6 @@ starpu_sched_component_heft_create parameters
      numa component it will be shared
 
 \fn struct starpu_sched_tree * starpu_sched_component_make_scheduler(unsigned sched_ctx_id, struct starpu_sched_specs s);
-\ingroup API_Hierarchical_Scheduler
+\ingroup API_Modularized_Scheduler
 	 this function build a scheduler for \p sched_ctx_id according to \p s and the hwloc topology of the machine.
 */

doc/doxygen/chapters/introduction.doxy

@@ -220,9 +220,9 @@ The documentation chapters include
 <li> \ref cExtensions
 <li> \ref SOCLOpenclExtensions
 <li> \ref SchedulingContexts
-<li> \ref HierarchicalScheduler
+<li> \ref ModularizedScheduler
 <li> \ref SchedulingContextHypervisor
-<li> \ref HierarchicalScheduler
+<li> \ref ModularizedScheduler
 </ul>
 </li>
 <li> Part: Inside StarPU

doc/doxygen/chapters/hierarchical_scheduler.doxy

@@ -5,12 +5,12 @@
  * See the file version.doxy for copying conditions.
  */
 
-/*! \page HierarchicalScheduler Hierarchical Schedulers
+/*! \page ModularizedScheduler Modularized Schedulers
 
 \section Introduction
 
-StarPU's Hierarchical Schedulers are made of individual Scheduling Components 
-hierarchically assembled as a Scheduling Tree. Each Scheduling Component has an 
+StarPU's Modularized Schedulers are made of individual Scheduling Components 
+Modularizedly assembled as a Scheduling Tree. Each Scheduling Component has an 
 unique purpose, such as prioritizing tasks or mapping tasks over resources.
 A typical Scheduling Tree is shown below.
 
@@ -38,21 +38,21 @@ A typical Scheduling Tree is shown below.
             Worker_Component               Worker_Component
 </pre>
 
-When a task is pushed by StarPU in a Hierarchical Scheduler, the task moves from
+When a task is pushed by StarPU in a Modularized Scheduler, the task moves from
 a Scheduling Component to an other, following the hierarchy of the
 Scheduling Tree, and is stored in one of the Scheduling Components of the 
 strategy.
-When a worker wants to pop a task from the Hierarchical Scheduler, the
+When a worker wants to pop a task from the Modularized Scheduler, the
 corresponding Worker Component of the Scheduling Tree tries to pull a task from 
 its parents, following the hierarchy, and gives it to the worker if it succeded 
 to get one.
 
 
-\section UsingHierarchicalSchedulers Using Hierarchical Schedulers
+\section UsingModularizedSchedulers Using Modularized Schedulers
 
-\subsection ExistingHierarchicalSchedulers Existing Hierarchical Schedulers
+\subsection ExistingModularizedSchedulers Existing Modularized Schedulers
 
-StarPU is currently shipped with the following pre-defined Hierarchical 
+StarPU is currently shipped with the following pre-defined Modularized 
 Schedulers :
 
 - Eager-based Schedulers (with/without prefetching) : \n
@@ -74,7 +74,7 @@ to work efficiently, but can handle tasks without a performance
 model.
 
 It is currently needed to set the environment variable \ref STARPU_SCHED 
-to use those Schedulers. Hierarchical Schedulers' naming is tree-*
+to use those Schedulers. Modularized Schedulers' naming is tree-*
 
 \subsection ExampleTreeEagerPrefetchingStrategy An Example : The Tree-Eager-Prefetching Strategy
 
@@ -110,7 +110,7 @@ to be able to interact with other Scheduling Components.
 	- Push (Caller_Component, Child_Component, Task) \n
 	The calling Scheduling Component transfers a task to its 
 	Child Component. When the Push function returns, the task no longer 
-	belongs to the calling Component. The Hierarchical Schedulers' 
+	belongs to the calling Component. The Modularized Schedulers' 
 	model relies on this function to perform prefetching.
 
 	- Pull (Caller_Component, Parent_Component)  ->  Task \n
@@ -127,7 +127,7 @@ to be able to interact with other Scheduling Components.
 	that it is ready to give new tasks.
 
 
-\section BuildAHierarchicalScheduler Build a Hierarchical Scheduler
+\section BuildAModularizedScheduler Build a Modularized Scheduler
 
 \subsection PreImplementedComponents Pre-implemented Components
 
@@ -155,20 +155,20 @@ StarPU is currently shipped with the following four Scheduling Components :
 
 \subsection ProgressionAndValidationRules Progression And Validation Rules
 
-Some rules must be followed to ensure the correctness of a Hierarchical 
+Some rules must be followed to ensure the correctness of a Modularized 
 Scheduler :
 
 	- At least one Flow-control Component without threshold per Worker Component 
-	is needed in a Hierarchical Scheduler, to store incoming tasks from StarPU 
+	is needed in a Modularized Scheduler, to store incoming tasks from StarPU 
 	and to give tasks to Worker Components who asks for it. It is possible to 
 	use one Flow-control Component per Worker Component, or one for all Worker
 	Components, depending on how the Scheduling Tree is defined.
 
-	- At least one Resource-Mapping Component is needed in a Hierarchical
+	- At least one Resource-Mapping Component is needed in a Modularized
 	Scheduler. Resource-Mapping Components are the only ones who can make
 	scheduling choices, and so the only ones who can have several child.
 
-\subsection ImplementAHierarchicalScheduler Implement a Hierarchical Scheduler
+\subsection ImplementAModularizedScheduler Implement a Modularized Scheduler
 
 The following code shows how the Tree-Eager-Prefetching Scheduler
 shown in Section \ref ExampleTreeEagerPrefetchingStrategy is implemented :
@@ -207,7 +207,7 @@ static void initialize_eager_prefetching_center_policy(unsigned sched_ctx_id)
     (eager_component, t->root);
 
   /* A task threshold is set for the Flow-control Components which will 
-   * be connected to Worker Components. By doing so, this Hierarchical 
+   * be connected to Worker Components. By doing so, this Modularized 
    * Scheduler will be able to perform some prefetching on the resources 
    */
   struct starpu_fifo_data fifo_data =
@@ -257,9 +257,9 @@ static void deinitialize_eager_prefetching_center_policy(unsigned sched_ctx_id)
     (sched_ctx_id);
 }
 
-/* Initializing the starpu_sched_policy struct associated to the Hierarchical
+/* Initializing the starpu_sched_policy struct associated to the Modularized
  * Scheduler : only the init_sched and deinit_sched needs to be defined to
- * implement a Hierarchical Scheduler */
+ * implement a Modularized Scheduler */
 struct starpu_sched_policy _starpu_sched_tree_eager_prefetching_policy =
 {
   .init_sched = initialize_eager_prefetching_center_policy,
@@ -284,10 +284,10 @@ Each Scheduling Component is instantiated from a Generic Scheduling Component,
 which implements a generic version of the Interface. The generic implementation
 of Pull, Can_Pull and Can_Push functions are recursive calls to their parents
 (respectively to their children). However, as a Generic Scheduling Component do
-not know how much children it will have when it will be instantiated, it do not
-implements the Push function.
+not know how much children it will have when it will be instantiated, it does 
+not implement the Push function.
 
-\subsection InstanciationRedefineInterface Instanciation : Redefine the Interface
+\subsection InstantiationRedefineInterface Instantiation : Redefine the Interface
 
 A Scheduling Component must implement all the functions of the Interface. It is
 so necessary to implement a Push function to instantiate a Scheduling Component.

doc/doxygen/refman.tex

@@ -168,10 +168,10 @@ Documentation License”.
 \hypertarget{SchedulingContextHypervisor}{}
 \input{SchedulingContextHypervisor}
 
-\chapter{Hierarchical Scheduler}
-\label{HierarchicalScheduler}
-\hypertarget{HierarchicalScheduler}{}
-\input{HierarchicalScheduler}
+\chapter{Modularized Scheduler}
+\label{ModularizedScheduler}
+\hypertarget{ModularizedScheduler}{}
+\input{ModularizedScheduler}
 
 \part{Inside StarPU}
 
@@ -228,7 +228,7 @@ Documentation License”.
 \input{group__API__Scheduling__Policy}
 \input{group__API__SC__Hypervisor__usage}
 \input{group__API__SC__Hypervisor}
-\input{group__API__Hierarchical__Scheduler}
+\input{group__API__Modularized__Scheduler}
 
 \chapter{File Index}
 \input{files}

include/starpu_sched_component.h

@@ -130,7 +130,7 @@ struct starpu_sched_component
 	int properties;
 
 #ifdef STARPU_HAVE_HWLOC
-	/* in case of a hierarchical scheduler, this is set to the part of
+	/* in case of a modularized scheduler, this is set to the part of
 	 * topology that is binded to this component, eg: a numa node for a ws
 	 * component that would balance load between underlying sockets
 	 */