Refactor to move alloc stuff to corealloc.c (5/7)
authorKevin Klues <klueska@cs.berkeley.edu>
Tue, 29 Sep 2015 01:00:59 +0000 (18:00 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Tue, 24 Nov 2015 19:48:50 +0000 (14:48 -0500)
This commit moves the find_best_core() function out of schedule.c and
puts it in corealloc.c. It is renamed to __find_best_core_to_alloc() to
make it clearer what its intended purpose is.

Signed-off-by: Kevin Klues <klueska@cs.berkeley.edu>
Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
kern/include/corerequest.h
kern/src/corealloc.c
kern/src/schedule.c

index 77be80b..8db875a 100644 (file)
@@ -30,6 +30,11 @@ void corealloc_init(void);
 /* Initialize any data associated with provisiong cores to a process. */
 void coreprov_proc_init(struct proc *p);
 
+/* Find the best core to allocate to a process as dictated by the core
+ * allocation algorithm. This code assumes that the scheduler that uses it
+ * holds a lock for the duration of the call. */
+struct sched_pcore *__find_best_core_to_alloc(struct proc *p);
+
 /* Track the pcore properly when it is allocated to p. This code assumes that
  * the scheduler that uses it holds a lock for the duration of the call. */
 void __track_core_alloc(struct proc *p, uint32_t pcoreid);
index 4ab5d02..4493a8b 100644 (file)
@@ -35,6 +35,19 @@ void corealloc_init(void)
 #endif /* CONFIG_DISABLE_SMT */
 }
 
+/* Find the best core to allocate to a process as dictated by the core
+ * allocation algorithm. This code assumes that the scheduler that uses it
+ * holds a lock for the duration of the call. */
+struct sched_pcore *__find_best_core_to_alloc(struct proc *p)
+{
+       struct sched_pcore *spc_i = NULL;
+
+       spc_i = TAILQ_FIRST(&p->ksched_data.crd.prov_not_alloc_me);
+       if (!spc_i)
+               spc_i = TAILQ_FIRST(&idlecores);
+       return spc_i;
+}
+
 /* Track the pcore properly when it is allocated to p. This code assumes that
  * the scheduler that uses it holds a lock for the duration of the call. */
 void __track_core_alloc(struct proc *p, uint32_t pcoreid)
index a7ded50..fa976b3 100644 (file)
@@ -546,19 +546,6 @@ uint32_t max_vcores(struct proc *p)
 #endif /* CONFIG_DISABLE_SMT */
 }
 
-/* Find the best core to give to p. First check p's list of cores
- * provisioned to it, but not yet allocated. If no cores are found, try and
- * pull from the idle list.  If no cores found on either list, return NULL.
- * */
-struct sched_pcore *find_best_core(struct proc *p)
-{
-       struct sched_pcore *spc_i = NULL;
-       spc_i = TAILQ_FIRST(&p->ksched_data.crd.prov_not_alloc_me);
-       if (!spc_i)
-               spc_i = TAILQ_FIRST(&idlecores);
-       return spc_i;
-}
-
 /* This deals with a request for more cores.  The amt of new cores needed is
  * passed in.  The ksched lock is held, but we are free to unlock if we want
  * (and we must, if calling out of the ksched to anything high-level).
@@ -583,7 +570,7 @@ static void __core_request(struct proc *p, uint32_t amt_needed)
        while (nr_to_grant != amt_needed) {
                /* Find the next best core to allocate to p. It may be a core
                 * provisioned to p, and it might not be. */
-               spc_i = find_best_core(p);
+               spc_i = __find_best_core_to_alloc(p);
                /* If no core is returned, we know that there are no more cores to give
                 * out, so we exit the loop. */
                if (spc_i == NULL)