Move sched_pcore and friends to corerequest.h
authorKevin Klues <klueska@cs.berkeley.edu>
Mon, 28 Sep 2015 21:04:10 +0000 (14:04 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Tue, 24 Nov 2015 19:48:50 +0000 (14:48 -0500)
We are now starting to begin our separation of corerequest logic from
scheduler logic so that alternate core request strategies can be chosen.
This commit simply moves the sched_pcore struct and parts of the
sched_proc_data into corelloc.h (which is now contained in a standalong
corerequest_data struct). We still need access to corerequest_data
inside sched_proc_data, we just embed it now as its own type in a field
called 'crd' (for core_request_data). As such, we've had to modify
schedule.c to access this data through that field.

Eventually, all code that ever references 'crd' will sit inside
coreprov.c and corealloc.c, and schedule.c will not reference it
directly.

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

index ec30345..0b03052 100644 (file)
@@ -6,3 +6,20 @@
  */
 
 #pragma once
+
+/* The core request algorithm maintains an internal array of these: the
+ * global pcore map. Note the prov_proc and alloc_proc are weak (internal)
+ * references, and should only be used as a ref source while the ksched has a
+ * valid kref. */
+struct sched_pcore {
+       TAILQ_ENTRY(sched_pcore)   prov_next;    /* on a proc's prov list */
+       TAILQ_ENTRY(sched_pcore)   alloc_next;   /* on an alloc list (idle)*/
+       struct proc                *prov_proc;   /* who this is prov to */
+       struct proc                *alloc_proc;  /* who this is alloc to */
+};
+TAILQ_HEAD(sched_pcore_tailq, sched_pcore);
+
+struct core_request_data {
+       struct sched_pcore_tailq  prov_alloc_me;      /* prov cores alloced us */
+       struct sched_pcore_tailq  prov_not_alloc_me;  /* maybe alloc to others */
+};
index f1e276f..f278bd1 100644 (file)
 
 #include <ros/common.h>
 #include <sys/queue.h>
+#include <corerequest.h>
 
 struct proc;   /* process.h includes us, but we need pointers now */
 TAILQ_HEAD(proc_list, proc);           /* Declares 'struct proc_list' */
 
-/* The ksched maintains an internal array of these: the global pcore map.  Note
- * the prov_proc and alloc_proc are weak (internal) references, and should only
- * be used as a ref source while the ksched has a valid kref. */
-struct sched_pcore {
-       TAILQ_ENTRY(sched_pcore)        prov_next;                      /* on a proc's prov list */
-       TAILQ_ENTRY(sched_pcore)        alloc_next;                     /* on an alloc list (idle)*/
-       struct proc                                     *prov_proc;                     /* who this is prov to */
-       struct proc                                     *alloc_proc;            /* who this is alloc to */
-};
-TAILQ_HEAD(sched_pcore_tailq, sched_pcore);
-
 /* One of these embedded in every struct proc */
 struct sched_proc_data {
        TAILQ_ENTRY(proc)                       proc_link;                      /* tailq linkage */
        struct proc_list                        *cur_list;                      /* which tailq we're on */
-       struct sched_pcore_tailq        prov_alloc_me;          /* prov cores alloced us */
-       struct sched_pcore_tailq        prov_not_alloc_me;      /* maybe alloc to others */
+       struct core_request_data        crd;                            /* prov/alloc cores */
        /* count of lists? */
        /* other accounting info */
 };
index fc60822..352aa47 100644 (file)
@@ -202,8 +202,8 @@ void __sched_proc_register(struct proc *p)
        /* one ref for the proc's existence, cradle-to-grave */
        proc_incref(p, 1);      /* need at least this OR the 'one for existing' */
        spin_lock(&sched_lock);
-       TAILQ_INIT(&p->ksched_data.prov_alloc_me);
-       TAILQ_INIT(&p->ksched_data.prov_not_alloc_me);
+       TAILQ_INIT(&p->ksched_data.crd.prov_alloc_me);
+       TAILQ_INIT(&p->ksched_data.crd.prov_not_alloc_me);
        add_to_list(p, &unrunnable_scps);
        spin_unlock(&sched_lock);
 }
@@ -258,8 +258,8 @@ void __sched_proc_destroy(struct proc *p, uint32_t *pc_arr, uint32_t nr_cores)
        /* Unprovision any cores.  Note this is different than track_dealloc.
         * The latter does bookkeeping when an allocation changes.  This is a
         * bulk *provisioning* change. */
-       unprov_pcore_list(&p->ksched_data.prov_alloc_me);
-       unprov_pcore_list(&p->ksched_data.prov_not_alloc_me);
+       unprov_pcore_list(&p->ksched_data.crd.prov_alloc_me);
+       unprov_pcore_list(&p->ksched_data.crd.prov_not_alloc_me);
        /* Remove from whatever list we are on (if any - might not be on one if it
         * was in the middle of __run_mcp_sched) */
        remove_from_any_list(p);
@@ -632,7 +632,7 @@ uint32_t max_vcores(struct proc *p)
 struct sched_pcore *find_best_core(struct proc *p)
 {
        struct sched_pcore *spc_i = NULL;
-       spc_i = TAILQ_FIRST(&p->ksched_data.prov_not_alloc_me);
+       spc_i = TAILQ_FIRST(&p->ksched_data.crd.prov_not_alloc_me);
        if (!spc_i)
                spc_i = TAILQ_FIRST(&idlecores);
        return spc_i;
@@ -794,8 +794,8 @@ static void __prov_track_alloc(struct proc *p, uint32_t pcoreid)
        spc->alloc_proc = p;
        /* if the pcore is prov to them and now allocated, move lists */
        if (spc->prov_proc == p) {
-               TAILQ_REMOVE(&p->ksched_data.prov_not_alloc_me, spc, prov_next);
-               TAILQ_INSERT_TAIL(&p->ksched_data.prov_alloc_me, spc, prov_next);
+               TAILQ_REMOVE(&p->ksched_data.crd.prov_not_alloc_me, spc, prov_next);
+               TAILQ_INSERT_TAIL(&p->ksched_data.crd.prov_alloc_me, spc, prov_next);
        }
        /* Actually allocate the core, removing it from the idle core list. */
        TAILQ_REMOVE(&idlecores, spc, alloc_next);
@@ -811,12 +811,13 @@ static void __prov_track_dealloc(struct proc *p, uint32_t pcoreid)
        spc->alloc_proc = 0;
        /* if the pcore is prov to them and now deallocated, move lists */
        if (spc->prov_proc == p) {
-               TAILQ_REMOVE(&p->ksched_data.prov_alloc_me, spc, prov_next);
+               TAILQ_REMOVE(&p->ksched_data.crd.prov_alloc_me, spc, prov_next);
                /* this is the victim list, which can be sorted so that we pick the
                 * right victim (sort by alloc_proc reverse priority, etc).  In this
                 * case, the core isn't alloc'd by anyone, so it should be the first
                 * victim. */
-               TAILQ_INSERT_HEAD(&p->ksched_data.prov_not_alloc_me, spc, prov_next);
+               TAILQ_INSERT_HEAD(&p->ksched_data.crd.prov_not_alloc_me, spc,
+                                 prov_next);
        }
        /* Actually dealloc the core, putting it back on the idle core list. */
        TAILQ_INSERT_TAIL(&idlecores, spc, alloc_next);
@@ -857,19 +858,20 @@ int provision_core(struct proc *p, uint32_t pcoreid)
                /* 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.prov_alloc_me :
-                            &spc->prov_proc->ksched_data.prov_not_alloc_me);
+                            &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.prov_alloc_me, spc, prov_next);
+                       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.prov_not_alloc_me, spc,
+                       TAILQ_INSERT_TAIL(&p->ksched_data.crd.prov_not_alloc_me, spc,
                                          prov_next);
                }
        }
@@ -947,10 +949,10 @@ void print_proc_prov(struct proc *p)
        if (!p)
                return;
        printk("Prov cores alloced to proc %d (%p)\n----------\n", p->pid, p);
-       TAILQ_FOREACH(spc_i, &p->ksched_data.prov_alloc_me, prov_next)
+       TAILQ_FOREACH(spc_i, &p->ksched_data.crd.prov_alloc_me, prov_next)
                printk("Pcore %d\n", spc2pcoreid(spc_i));
        printk("Prov cores not alloced to proc %d (%p)\n----------\n", p->pid, p);
-       TAILQ_FOREACH(spc_i, &p->ksched_data.prov_not_alloc_me, prov_next)
+       TAILQ_FOREACH(spc_i, &p->ksched_data.crd.prov_not_alloc_me, prov_next)
                printk("Pcore %d (alloced to %d (%p))\n", spc2pcoreid(spc_i),
                       spc_i->alloc_proc ? spc_i->alloc_proc->pid : 0,
                       spc_i->alloc_proc);