renaming ctl keys

doc/doxygen/chapters/api/scheduling_context_hypervisor.doxy

@@ -183,7 +183,7 @@ Requires reconsidering the distribution of ressources over the indicated schedul
 Inputs conditions to the context sched_ctx with the following
 arguments. The argument list must be zero-terminated.
 
-\def HYPERVISOR_MAX_IDLE
+\def SC_HYPERVISOR_MAX_IDLE
 \ingroup API_Scheduling_Context_Hypervisor
 This macro is used when calling sc_hypervisor_ctl() and must be
 followed by 3 arguments: an array of int for the workerids to apply
@@ -191,7 +191,7 @@ the condition, an int to indicate the size of the array, and a double
 value indicating the maximum idle time allowed for a worker before the
 resizing process should be triggered
 
-\def HYPERVISOR_PRIORITY
+\def SC_HYPERVISOR_PRIORITY
 \ingroup API_Scheduling_Context_Hypervisor
 This macro is used when calling sc_hypervisor_ctl() and must be
 followed by 3 arguments: an array of int for the workerids to apply
@@ -199,20 +199,20 @@ the condition, an int to indicate the size of the array, and an int
 value indicating the priority of the workers previously mentioned. The
 workers with the smallest priority are moved the first.
 
-\def HYPERVISOR_MIN_WORKERS
+\def SC_HYPERVISOR_MIN_WORKERS
 \ingroup API_Scheduling_Context_Hypervisor
 This macro is used when calling sc_hypervisor_ctl() and must be
 followed by 1 argument(int) indicating the minimum number of workers a
 context should have, underneath this limit the context cannot execute.
 
-\def HYPERVISOR_MAX_WORKERS
+\def SC_HYPERVISOR_MAX_WORKERS
 \ingroup API_Scheduling_Context_Hypervisor
 This macro is used when calling sc_hypervisor_ctl() and must be
 followed by 1 argument(int) indicating the maximum number of workers a
 context should have, above this limit the context would not be able to
 scale
 
-\def HYPERVISOR_GRANULARITY
+\def SC_HYPERVISOR_GRANULARITY
 \ingroup API_Scheduling_Context_Hypervisor
 This macro is used when calling sc_hypervisor_ctl() and must be
 followed by 1 argument(int) indicating the granularity of the resizing
@@ -221,14 +221,14 @@ it is resized) This parameter is ignore for the Gflops rate based
 strategy (see \ref ResizingStrategies), the number of workers that have to
 be moved is calculated by the strategy.
 
-\def HYPERVISOR_FIXED_WORKERS
+\def SC_HYPERVISOR_FIXED_WORKERS
 \ingroup API_Scheduling_Context_Hypervisor
 This macro is used when calling sc_hypervisor_ctl() and must be
 followed by 2 arguments: an array of int for the workerids to apply
 the condition and an int to indicate the size of the array. These
 workers are not allowed to be moved from the context.
 
-\def HYPERVISOR_MIN_TASKS
+\def SC_HYPERVISOR_MIN_TASKS
 \ingroup API_Scheduling_Context_Hypervisor
 This macro is used when calling sc_hypervisor_ctl() and must be
 followed by 1 argument (int) that indicated the minimum number of
@@ -237,14 +237,14 @@ This parameter is ignored for the Application Driven strategy (see \ref
 ResizingStrategies) where the user indicates exactly when the resize
 should be done.
 
-\def HYPERVISOR_NEW_WORKERS_MAX_IDLE
+\def SC_HYPERVISOR_NEW_WORKERS_MAX_IDLE
 \ingroup API_Scheduling_Context_Hypervisor
 This macro is used when calling sc_hypervisor_ctl() and must be
 followed by 1 argument, a double value indicating the maximum idle
 time allowed for workers that have just been moved from other contexts
 in the current context.
 
-\def HYPERVISOR_TIME_TO_APPLY
+\def SC_HYPERVISOR_TIME_TO_APPLY
 \ingroup API_Scheduling_Context_Hypervisor
 This macro is used when calling sc_hypervisor_ctl() and must be
 followed by 1 argument (int) indicating the tag an executed task

doc/doxygen/chapters/scheduling_context_hypervisor.doxy

@@ -93,9 +93,9 @@ The user can use the same tag to change the resizing configuration of the contex
 
 \code{.c}
 sc_hypervisor_ctl(sched_ctx,
-                    HYPERVISOR_MIN_WORKERS, 6,
-                    HYPERVISOR_MAX_WORKERS, 12,
-                    HYPERVISOR_TIME_TO_APPLY, 2,
+                    SC_HYPERVISOR_MIN_WORKERS, 6,
+                    SC_HYPERVISOR_MAX_WORKERS, 12,
+                    SC_HYPERVISOR_TIME_TO_APPLY, 2,
                     NULL);
 \endcode
 
@@ -108,8 +108,8 @@ for a period longer than the one imposed by the user
 int workerids[3] = {1, 3, 10};
 int workerids2[9] = {0, 2, 4, 5, 6, 7, 8, 9, 11};
 sc_hypervisor_ctl(sched_ctx_id,
-            HYPERVISOR_MAX_IDLE, workerids, 3, 10000.0,
-            HYPERVISOR_MAX_IDLE, workerids2, 9, 50000.0,
+            SC_HYPERVISOR_MAX_IDLE, workerids, 3, 10000.0,
+            SC_HYPERVISOR_MAX_IDLE, workerids2, 9, 50000.0,
             NULL);
 \endcode
 

sc_hypervisor/examples/app_driven_test/app_driven_test.c

@@ -81,10 +81,10 @@ void* submit_tasks_thread(void *arg)
 			/* indicate particular settings the context should have when the 
 			   resizing will be done */
 			sc_hypervisor_ctl(sched_ctx,
-						   HYPERVISOR_TIME_TO_APPLY, tag,
-						   HYPERVISOR_MIN_WORKERS, 2,
-						   HYPERVISOR_MAX_WORKERS, 12,
-						   HYPERVISOR_NULL);
+						   SC_HYPERVISOR_TIME_TO_APPLY, tag,
+						   SC_HYPERVISOR_MIN_WORKERS, 2,
+						   SC_HYPERVISOR_MAX_WORKERS, 12,
+						   SC_HYPERVISOR_NULL);
 			printf("require resize for sched_ctx %d at tag %d\n", sched_ctx, tag);
 			/* specify that the contexts should be resized when the task having this
 			   particular tag will finish executing */

sc_hypervisor/examples/sched_ctx_utils/sched_ctx_utils.c

@@ -273,21 +273,21 @@ void construct_contexts(void (*bench)(float*, unsigned, unsigned))
 	sc_hypervisor_register_ctx(p1.ctx, 0.0);
 
 	/* sc_hypervisor_ctl(p1.ctx, */
-	/* 			   HYPERVISOR_MAX_IDLE, p1.workers, p1.nworkers, 5000.0, */
-	/* 			   HYPERVISOR_MAX_IDLE, p1.workers, gpu+gpu1, 100000.0, */
-	/* 			   HYPERVISOR_EMPTY_CTX_MAX_IDLE, p1.workers, p1.nworkers, 500000.0, */
-	/* 			   HYPERVISOR_GRANULARITY, 2, */
-	/* 			   HYPERVISOR_MIN_TASKS, 1000, */
-	/* 			   HYPERVISOR_NEW_WORKERS_MAX_IDLE, 100000.0, */
-	/* 			   HYPERVISOR_MIN_WORKERS, 6, */
-	/* 			   HYPERVISOR_MAX_WORKERS, 12, */
+	/* 			   SC_HYPERVISOR_MAX_IDLE, p1.workers, p1.nworkers, 5000.0, */
+	/* 			   SC_HYPERVISOR_MAX_IDLE, p1.workers, gpu+gpu1, 100000.0, */
+	/* 			   SC_HYPERVISOR_EMPTY_CTX_MAX_IDLE, p1.workers, p1.nworkers, 500000.0, */
+	/* 			   SC_HYPERVISOR_GRANULARITY, 2, */
+	/* 			   SC_HYPERVISOR_MIN_TASKS, 1000, */
+	/* 			   SC_HYPERVISOR_NEW_WORKERS_MAX_IDLE, 100000.0, */
+	/* 			   SC_HYPERVISOR_MIN_WORKERS, 6, */
+	/* 			   SC_HYPERVISOR_MAX_WORKERS, 12, */
 	/* 			   NULL); */
 
 	sc_hypervisor_ctl(p1.ctx,
-				   HYPERVISOR_GRANULARITY, 2,
-				   HYPERVISOR_MIN_TASKS, 1000,
-				   HYPERVISOR_MIN_WORKERS, 6,
-				   HYPERVISOR_MAX_WORKERS, 12,
+				   SC_HYPERVISOR_GRANULARITY, 2,
+				   SC_HYPERVISOR_MIN_TASKS, 1000,
+				   SC_HYPERVISOR_MIN_WORKERS, 6,
+				   SC_HYPERVISOR_MAX_WORKERS, 12,
 				   NULL);
 
 	k = 0;
@@ -309,21 +309,21 @@ void construct_contexts(void (*bench)(float*, unsigned, unsigned))
 	sc_hypervisor_register_ctx(p2.ctx, 0.0);
 
 	/* sc_hypervisor_ctl(p2.ctx, */
-	/* 			   HYPERVISOR_MAX_IDLE, p2.workers, p2.nworkers, 2000.0, */
-	/* 			   HYPERVISOR_MAX_IDLE, p2.workers, gpu+gpu2, 5000.0, */
-	/* 			   HYPERVISOR_EMPTY_CTX_MAX_IDLE, p1.workers, p1.nworkers, 500000.0, */
-	/* 			   HYPERVISOR_GRANULARITY, 2, */
-	/* 			   HYPERVISOR_MIN_TASKS, 500, */
-	/* 			   HYPERVISOR_NEW_WORKERS_MAX_IDLE, 1000.0, */
-	/* 			   HYPERVISOR_MIN_WORKERS, 4, */
-	/* 			   HYPERVISOR_MAX_WORKERS, 8, */
+	/* 			   SC_HYPERVISOR_MAX_IDLE, p2.workers, p2.nworkers, 2000.0, */
+	/* 			   SC_HYPERVISOR_MAX_IDLE, p2.workers, gpu+gpu2, 5000.0, */
+	/* 			   SC_HYPERVISOR_EMPTY_CTX_MAX_IDLE, p1.workers, p1.nworkers, 500000.0, */
+	/* 			   SC_HYPERVISOR_GRANULARITY, 2, */
+	/* 			   SC_HYPERVISOR_MIN_TASKS, 500, */
+	/* 			   SC_HYPERVISOR_NEW_WORKERS_MAX_IDLE, 1000.0, */
+	/* 			   SC_HYPERVISOR_MIN_WORKERS, 4, */
+	/* 			   SC_HYPERVISOR_MAX_WORKERS, 8, */
 	/* 			   NULL); */
 
 	sc_hypervisor_ctl(p2.ctx,
-				   HYPERVISOR_GRANULARITY, 2,
-				   HYPERVISOR_MIN_TASKS, 500,
-				   HYPERVISOR_MIN_WORKERS, 0,
-				   HYPERVISOR_MAX_WORKERS, 6,
+				   SC_HYPERVISOR_GRANULARITY, 2,
+				   SC_HYPERVISOR_MIN_TASKS, 500,
+				   SC_HYPERVISOR_MIN_WORKERS, 0,
+				   SC_HYPERVISOR_MAX_WORKERS, 6,
 				   NULL);
 
 }
@@ -338,16 +338,16 @@ void set_hypervisor_conf(int event, int task_tag)
 /* 			if(it < 2) */
 /* 			{ */
 /* 				sc_hypervisor_ctl(p2.ctx, */
-/* 							   HYPERVISOR_MIN_WORKERS, 2, */
-/* 							   HYPERVISOR_MAX_WORKERS, 4, */
-/* 							   HYPERVISOR_TIME_TO_APPLY, task_tag, */
+/* 							   SC_HYPERVISOR_MIN_WORKERS, 2, */
+/* 							   SC_HYPERVISOR_MAX_WORKERS, 4, */
+/* 							   SC_HYPERVISOR_TIME_TO_APPLY, task_tag, */
 /* 							   NULL); */
 
 /* 				printf("%d: set max %d for tag %d\n", p2.ctx, 4, task_tag); */
 /* 				sc_hypervisor_ctl(p1.ctx, */
-/* 							   HYPERVISOR_MIN_WORKERS, 6, */
-/* 							   HYPERVISOR_MAX_WORKERS, 8, */
-/* 							   HYPERVISOR_TIME_TO_APPLY, task_tag, */
+/* 							   SC_HYPERVISOR_MIN_WORKERS, 6, */
+/* 							   SC_HYPERVISOR_MAX_WORKERS, 8, */
+/* 							   SC_HYPERVISOR_TIME_TO_APPLY, task_tag, */
 /* 							   NULL); */
 /* 				printf("%d: set max %d for tag %d\n", p1.ctx, 8, task_tag); */
 /* 				sc_hypervisor_resize(p1.ctx, task_tag); */
@@ -355,15 +355,15 @@ void set_hypervisor_conf(int event, int task_tag)
 /* 			if(it == 2) */
 /* 			{ */
 /* 				sc_hypervisor_ctl(p2.ctx, */
-/* 							   HYPERVISOR_MIN_WORKERS, 12, */
-/* 							   HYPERVISOR_MAX_WORKERS, 12, */
-/* 							   HYPERVISOR_TIME_TO_APPLY, task_tag, */
+/* 							   SC_HYPERVISOR_MIN_WORKERS, 12, */
+/* 							   SC_HYPERVISOR_MAX_WORKERS, 12, */
+/* 							   SC_HYPERVISOR_TIME_TO_APPLY, task_tag, */
 /* 							   NULL); */
 /* 				printf("%d: set max %d for tag %d\n", p2.ctx, 12, task_tag); */
 /* 				sc_hypervisor_ctl(p1.ctx, */
-/* 							   HYPERVISOR_MIN_WORKERS, 0, */
-/* 							   HYPERVISOR_MAX_WORKERS, 0, */
-/* 							   HYPERVISOR_TIME_TO_APPLY, task_tag, */
+/* 							   SC_HYPERVISOR_MIN_WORKERS, 0, */
+/* 							   SC_HYPERVISOR_MAX_WORKERS, 0, */
+/* 							   SC_HYPERVISOR_TIME_TO_APPLY, task_tag, */
 /* 							   NULL); */
 /* 				printf("%d: set max %d for tag %d\n", p1.ctx, 0, task_tag); */
 /* 				sc_hypervisor_resize(p1.ctx, task_tag); */
@@ -379,15 +379,15 @@ void set_hypervisor_conf(int event, int task_tag)
 /* 			if(it2 < 3) */
 /* 			{ */
 /* 				sc_hypervisor_ctl(p1.ctx, */
-/* 							   HYPERVISOR_MIN_WORKERS, 6, */
-/* 							   HYPERVISOR_MAX_WORKERS, 12, */
-/* 							   HYPERVISOR_TIME_TO_APPLY, task_tag, */
+/* 							   SC_HYPERVISOR_MIN_WORKERS, 6, */
+/* 							   SC_HYPERVISOR_MAX_WORKERS, 12, */
+/* 							   SC_HYPERVISOR_TIME_TO_APPLY, task_tag, */
 /* 							   NULL); */
 /* 				printf("%d: set max %d for tag %d\n", p1.ctx, 12, task_tag); */
 /* 				sc_hypervisor_ctl(p2.ctx, */
-/* 							   HYPERVISOR_MIN_WORKERS, 0, */
-/* 							   HYPERVISOR_MAX_WORKERS, 0, */
-/* 							   HYPERVISOR_TIME_TO_APPLY, task_tag, */
+/* 							   SC_HYPERVISOR_MIN_WORKERS, 0, */
+/* 							   SC_HYPERVISOR_MAX_WORKERS, 0, */
+/* 							   SC_HYPERVISOR_TIME_TO_APPLY, task_tag, */
 /* 							   NULL); */
 /* 				printf("%d: set max %d for tag %d\n", p2.ctx, 0, task_tag); */
 /* 				sc_hypervisor_resize(p2.ctx, task_tag); */
@@ -402,8 +402,8 @@ void set_hypervisor_conf(int event, int task_tag)
 	/* 	{ */
 	/* 		int workers[12] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}; */
 	/* 		sc_hypervisor_ctl(p1.ctx, */
-	/* 					   HYPERVISOR_MAX_IDLE, workers, 12, 800000.0, */
-	/* 					   HYPERVISOR_TIME_TO_APPLY, task_tag, */
+	/* 					   SC_HYPERVISOR_MAX_IDLE, workers, 12, 800000.0, */
+	/* 					   SC_HYPERVISOR_TIME_TO_APPLY, task_tag, */
 	/* 					   NULL); */
 	/* 	} */
 	/* 	else */
@@ -412,19 +412,19 @@ void set_hypervisor_conf(int event, int task_tag)
 	/* 		{ */
 	/* 			int workers[12] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}; */
 	/* 			sc_hypervisor_ctl(p2.ctx, */
-	/* 						   HYPERVISOR_MAX_IDLE, workers, 12, 500.0, */
-	/* 						   HYPERVISOR_MAX_IDLE, workers, 3, 200.0, */
-	/* 						   HYPERVISOR_TIME_TO_APPLY, task_tag, */
+	/* 						   SC_HYPERVISOR_MAX_IDLE, workers, 12, 500.0, */
+	/* 						   SC_HYPERVISOR_MAX_IDLE, workers, 3, 200.0, */
+	/* 						   SC_HYPERVISOR_TIME_TO_APPLY, task_tag, */
 	/* 						   NULL); */
 	/* 		} */
 	/* 		if(it2 == 2) */
 	/* 		{ */
 	/* 			int workers[12] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}; */
 	/* 			sc_hypervisor_ctl(p2.ctx, */
-	/* 						   HYPERVISOR_MAX_IDLE, workers, 12, 1000.0, */
-	/* 						   HYPERVISOR_MAX_IDLE, workers, 3, 500.0, */
-	/* 						   HYPERVISOR_TIME_TO_APPLY, task_tag, */
-	/* 						   HYPERVISOR_MAX_WORKERS, 12, */
+	/* 						   SC_HYPERVISOR_MAX_IDLE, workers, 12, 1000.0, */
+	/* 						   SC_HYPERVISOR_MAX_IDLE, workers, 3, 500.0, */
+	/* 						   SC_HYPERVISOR_TIME_TO_APPLY, task_tag, */
+	/* 						   SC_HYPERVISOR_MAX_WORKERS, 12, */
 	/* 						   NULL); */
 	/* 		} */
 	/* 		it2++; */
@@ -435,9 +435,9 @@ void set_hypervisor_conf(int event, int task_tag)
 	/* 	{ */
 	/* 		int workers[12] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}; */
 	/* 		sc_hypervisor_ctl(p1.ctx, */
-	/* 					   HYPERVISOR_MAX_IDLE, workers, 12, 1500.0, */
-	/* 					   HYPERVISOR_MAX_IDLE, workers, 3, 4000.0, */
-	/* 					   HYPERVISOR_TIME_TO_APPLY, task_tag, */
+	/* 					   SC_HYPERVISOR_MAX_IDLE, workers, 12, 1500.0, */
+	/* 					   SC_HYPERVISOR_MAX_IDLE, workers, 3, 4000.0, */
+	/* 					   SC_HYPERVISOR_TIME_TO_APPLY, task_tag, */
 	/* 					   NULL); */
 	/* 	} */
 	/* 	if(event == END_BENCH) */
@@ -446,18 +446,18 @@ void set_hypervisor_conf(int event, int task_tag)
 	/* 		{ */
 	/* 			int workers[12] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}; */
 	/* 			sc_hypervisor_ctl(p1.ctx, */
-	/* 						   HYPERVISOR_MAX_IDLE, workers, 12, 100.0, */
-	/* 						   HYPERVISOR_MAX_IDLE, workers, 3, 5000.0, */
-	/* 						   HYPERVISOR_TIME_TO_APPLY, task_tag, */
+	/* 						   SC_HYPERVISOR_MAX_IDLE, workers, 12, 100.0, */
+	/* 						   SC_HYPERVISOR_MAX_IDLE, workers, 3, 5000.0, */
+	/* 						   SC_HYPERVISOR_TIME_TO_APPLY, task_tag, */
 	/* 						   NULL); */
 	/* 		} */
 	/* 		if(it == 2) */
 	/* 		{ */
 	/* 			int workers[12] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}; */
 	/* 			sc_hypervisor_ctl(p1.ctx, */
-	/* 						   HYPERVISOR_MAX_IDLE, workers, 12, 5000.0, */
-	/* 						   HYPERVISOR_MAX_IDLE, workers, 3, 10000.0, */
-	/* 						   HYPERVISOR_TIME_TO_APPLY, task_tag, */
+	/* 						   SC_HYPERVISOR_MAX_IDLE, workers, 12, 5000.0, */
+	/* 						   SC_HYPERVISOR_MAX_IDLE, workers, 3, 10000.0, */
+	/* 						   SC_HYPERVISOR_TIME_TO_APPLY, task_tag, */
 	/* 						   NULL); */
 	/* 		} */
 

sc_hypervisor/include/sc_hypervisor_config.h

@@ -25,20 +25,20 @@ extern "C"
 #endif
 
 /* ctl properties*/
-#define HYPERVISOR_MAX_IDLE -1
-#define HYPERVISOR_MIN_WORKING -2
-#define HYPERVISOR_PRIORITY -3
-#define HYPERVISOR_MIN_WORKERS -4
-#define HYPERVISOR_MAX_WORKERS -5
-#define HYPERVISOR_GRANULARITY -6
-#define HYPERVISOR_FIXED_WORKERS -7
-#define HYPERVISOR_MIN_TASKS -8
-#define HYPERVISOR_NEW_WORKERS_MAX_IDLE -9
-#define HYPERVISOR_TIME_TO_APPLY -10
-#define HYPERVISOR_EMPTY_CTX_MAX_IDLE -11
-#define HYPERVISOR_NULL -12
-#define	HYPERVISOR_ISPEED_W_SAMPLE -13
-#define HYPERVISOR_ISPEED_CTX_SAMPLE -14
+#define SC_HYPERVISOR_MAX_IDLE -1
+#define SC_HYPERVISOR_MIN_WORKING -2
+#define SC_HYPERVISOR_PRIORITY -3
+#define SC_HYPERVISOR_MIN_WORKERS -4
+#define SC_HYPERVISOR_MAX_WORKERS -5
+#define SC_HYPERVISOR_GRANULARITY -6
+#define SC_HYPERVISOR_FIXED_WORKERS -7
+#define SC_HYPERVISOR_MIN_TASKS -8
+#define SC_HYPERVISOR_NEW_WORKERS_MAX_IDLE -9
+#define SC_HYPERVISOR_TIME_TO_APPLY -10
+#define SC_HYPERVISOR_EMPTY_CTX_MAX_IDLE -11
+#define SC_HYPERVISOR_NULL -12
+#define	SC_HYPERVISOR_ISPEED_W_SAMPLE -13
+#define SC_HYPERVISOR_ISPEED_CTX_SAMPLE -14
 
 
 #define MAX_IDLE_TIME 5000000000

sc_hypervisor/src/sc_config.c

@@ -118,11 +118,11 @@ static struct sc_hypervisor_policy_config* _ctl(unsigned sched_ctx, va_list varg
 	int *workerids;
 	int nworkers;
 
-	while ((arg_type = va_arg(varg_list, int)) != HYPERVISOR_NULL)
+	while ((arg_type = va_arg(varg_list, int)) != SC_HYPERVISOR_NULL)
 	{
 		switch(arg_type)
 		{
-		case HYPERVISOR_MAX_IDLE:
+		case SC_HYPERVISOR_MAX_IDLE:
 			workerids = va_arg(varg_list, int*);
 			nworkers = va_arg(varg_list, int);
 			double max_idle = va_arg(varg_list, double);
@@ -131,7 +131,7 @@ static struct sc_hypervisor_policy_config* _ctl(unsigned sched_ctx, va_list varg
 
 			break;
 
-		case HYPERVISOR_EMPTY_CTX_MAX_IDLE:
+		case SC_HYPERVISOR_EMPTY_CTX_MAX_IDLE:
 			workerids = va_arg(varg_list, int*);
 			nworkers = va_arg(varg_list, int);
 			double empty_ctx_max_idle = va_arg(varg_list, double);
@@ -141,7 +141,7 @@ static struct sc_hypervisor_policy_config* _ctl(unsigned sched_ctx, va_list varg
 
 			break;
 
-		case HYPERVISOR_MIN_WORKING:
+		case SC_HYPERVISOR_MIN_WORKING:
 			workerids = va_arg(varg_list, int*);
 			nworkers = va_arg(varg_list, int);
 			double min_working = va_arg(varg_list, double);
@@ -151,7 +151,7 @@ static struct sc_hypervisor_policy_config* _ctl(unsigned sched_ctx, va_list varg
 
 			break;
 
-		case HYPERVISOR_PRIORITY:
+		case SC_HYPERVISOR_PRIORITY:
 			workerids = va_arg(varg_list, int*);
 			nworkers = va_arg(varg_list, int);
 			int priority = va_arg(varg_list, int);
@@ -160,19 +160,19 @@ static struct sc_hypervisor_policy_config* _ctl(unsigned sched_ctx, va_list varg
 				config->priority[workerids[i]] = priority;
 			break;
 
-		case HYPERVISOR_MIN_WORKERS:
+		case SC_HYPERVISOR_MIN_WORKERS:
 			config->min_nworkers = va_arg(varg_list, unsigned);
 			break;
 
-		case HYPERVISOR_MAX_WORKERS:
+		case SC_HYPERVISOR_MAX_WORKERS:
 			config->max_nworkers = va_arg(varg_list, unsigned);
 			break;
 
-		case HYPERVISOR_GRANULARITY:
+		case SC_HYPERVISOR_GRANULARITY:
 			config->granularity = va_arg(varg_list, unsigned);
 			break;
 
-		case HYPERVISOR_FIXED_WORKERS:
+		case SC_HYPERVISOR_FIXED_WORKERS:
 			workerids = va_arg(varg_list, int*);
 			nworkers = va_arg(varg_list, int);
 
@@ -180,11 +180,11 @@ static struct sc_hypervisor_policy_config* _ctl(unsigned sched_ctx, va_list varg
 				config->fixed_workers[workerids[i]] = 1;
 			break;
 
-		case HYPERVISOR_NEW_WORKERS_MAX_IDLE:
+		case SC_HYPERVISOR_NEW_WORKERS_MAX_IDLE:
 			config->new_workers_max_idle = va_arg(varg_list, double);
 			break;
 
-		case HYPERVISOR_ISPEED_W_SAMPLE:
+		case SC_HYPERVISOR_ISPEED_W_SAMPLE:
 			workerids = va_arg(varg_list, int*);
 			nworkers = va_arg(varg_list, int);
 			double sample = va_arg(varg_list, double);
@@ -193,16 +193,16 @@ static struct sc_hypervisor_policy_config* _ctl(unsigned sched_ctx, va_list varg
 				config->ispeed_w_sample[workerids[i]] = sample;
 			break;
 
-		case HYPERVISOR_ISPEED_CTX_SAMPLE:
+		case SC_HYPERVISOR_ISPEED_CTX_SAMPLE:
 			config->ispeed_ctx_sample = va_arg(varg_list, double);
 			break;
 
 /* not important for the strateg, needed just to jump these args in the iteration of the args */
-		case HYPERVISOR_TIME_TO_APPLY:
+		case SC_HYPERVISOR_TIME_TO_APPLY:
 			va_arg(varg_list, int);
 			break;
 
-		case HYPERVISOR_MIN_TASKS:
+		case SC_HYPERVISOR_MIN_TASKS:
 			va_arg(varg_list, int);
 			break;
 
@@ -224,16 +224,16 @@ void sc_hypervisor_ctl(unsigned sched_ctx, ...)
 	int stop = 0;
 	int task_tag = -1;
 
-	while ((arg_type = va_arg(varg_list, int)) != HYPERVISOR_NULL)
+	while ((arg_type = va_arg(varg_list, int)) != SC_HYPERVISOR_NULL)
 	{
 		switch(arg_type)
 		{
-		case HYPERVISOR_TIME_TO_APPLY:
+		case SC_HYPERVISOR_TIME_TO_APPLY:
 			task_tag = va_arg(varg_list, int);
 			stop = 1;
 			break;
 
-		case HYPERVISOR_MIN_TASKS:
+		case SC_HYPERVISOR_MIN_TASKS:
 			hypervisor.min_tasks = va_arg(varg_list, int);
 			hypervisor.check_min_tasks[sched_ctx] = 1;
 			break;