Refactor to move prov stuff to coreprov.c (1/4)
authorKevin Klues <klueska@cs.berkeley.edu>
Mon, 28 Sep 2015 21:16:04 +0000 (14:16 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Tue, 24 Nov 2015 19:48:50 +0000 (14:48 -0500)
In this commit we first move the primary logic for actually provisioning
a core out of schedule.c and into coreprov.c. In subsequent commits we
will move the rest of the functionality out as well.

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

index 7260fc3..60a4ec7 100644 (file)
@@ -24,6 +24,10 @@ struct core_request_data {
        struct sched_pcore_tailq  prov_not_alloc_me;  /* maybe alloc to others */
 };
 
+/* Provision a core to proc p. This code assumes that the scheduler that uses
+ * it holds a lock for the duration of the call. */
+void __provision_core(struct proc *p, struct sched_pcore *spc);
+
 static inline uint32_t spc2pcoreid(struct sched_pcore *spc)
 {
        extern struct sched_pcore *all_pcores;
index 6a55a9d..8e9d3b4 100644 (file)
@@ -5,3 +5,37 @@
  * See LICENSE for details.
  */
 
+#include <env.h>
+#include <schedule.h>
+
+/* Provision a core to proc p. This code assumes that the scheduler that uses
+ * it holds a lock for the duration of the call. */
+void __provision_core(struct proc *p, struct sched_pcore *spc)
+{
+       struct sched_pcore_tailq *prov_list;
+       /* If the core is already prov to someone else, take it away.  (last write
+        * wins, some other layer or new func can handle permissions). */
+       if (spc->prov_proc) {
+               /* the list the spc is on depends on whether it is alloced to the
+                * prov_proc or not */
+               prov_list = (spc->alloc_proc == spc->prov_proc ?
+                            &spc->prov_proc->ksched_data.crd.prov_alloc_me :
+                            &spc->prov_proc->ksched_data.crd.prov_not_alloc_me);
+               TAILQ_REMOVE(prov_list, spc, prov_next);
+       }
+       /* Now prov it to p.  Again, the list it goes on depends on whether it is
+        * alloced to p or not.  Callers can also send in 0 to de-provision. */
+       if (p) {
+               if (spc->alloc_proc == p) {
+                       TAILQ_INSERT_TAIL(&p->ksched_data.crd.prov_alloc_me, spc,
+                                         prov_next);
+               } else {
+                       /* this is be the victim list, which can be sorted so that we pick
+                        * the right victim (sort by alloc_proc reverse priority, etc). */
+                       TAILQ_INSERT_TAIL(&p->ksched_data.crd.prov_not_alloc_me, spc,
+                                         prov_next);
+               }
+       }
+       spc->prov_proc = p;
+}
+
index 5877d3e..cb49e2b 100644 (file)
@@ -819,11 +819,11 @@ static void __prov_track_dealloc_bulk(struct proc *p, uint32_t *pc_arr,
                __prov_track_dealloc(p, pc_arr[i]);
 }
 
-/* P will get pcore if it needs more cores next time we look at it */
+/* Provision a core to a process. This function wraps the primary logic
+ * implemented in __provision_core, with a lock, error checking, etc. */
 int provision_core(struct proc *p, uint32_t pcoreid)
 {
        struct sched_pcore *spc;
-       struct sched_pcore_tailq *prov_list;
        /* Make sure we aren't asking for something that doesn't exist (bounds check
         * on the pcore array) */
        if (!(pcoreid < num_cores)) {
@@ -840,30 +840,7 @@ int provision_core(struct proc *p, uint32_t pcoreid)
         * If we need a finer grained sched lock, this is one place where we could
         * have a different lock */
        spin_lock(&sched_lock);
-       /* If the core is already prov to someone else, take it away.  (last write
-        * wins, some other layer or new func can handle permissions). */
-       if (spc->prov_proc) {
-               /* the list the spc is on depends on whether it is alloced to the
-                * prov_proc or not */
-               prov_list = (spc->alloc_proc == spc->prov_proc ?
-                            &spc->prov_proc->ksched_data.crd.prov_alloc_me :
-                            &spc->prov_proc->ksched_data.crd.prov_not_alloc_me);
-               TAILQ_REMOVE(prov_list, spc, prov_next);
-       }
-       /* Now prov it to p.  Again, the list it goes on depends on whether it is
-        * alloced to p or not.  Callers can also send in 0 to de-provision. */
-       if (p) {
-               if (spc->alloc_proc == p) {
-                       TAILQ_INSERT_TAIL(&p->ksched_data.crd.prov_alloc_me, spc,
-                                         prov_next);
-               } else {
-                       /* this is be the victim list, which can be sorted so that we pick
-                        * the right victim (sort by alloc_proc reverse priority, etc). */
-                       TAILQ_INSERT_TAIL(&p->ksched_data.crd.prov_not_alloc_me, spc,
-                                         prov_next);
-               }
-       }
-       spc->prov_proc = p;
+       __provision_core(p, spc);
        spin_unlock(&sched_lock);
        return 0;
 }