Removes resource.c/h
authorBarret Rhoden <brho@cs.berkeley.edu>
Fri, 2 Mar 2012 01:16:47 +0000 (17:16 -0800)
committerBarret Rhoden <brho@cs.berkeley.edu>
Fri, 2 Mar 2012 18:54:30 +0000 (10:54 -0800)
Moves the only real functionality into the ksched (which will help with
the ghetto proc_wants_cores() calls).  core_request() is really just
"proc wants cores, find cores, give cores", which is the scheduler's
job.

kern/include/resource.h [deleted file]
kern/include/schedule.h
kern/src/Makefrag
kern/src/manager.c
kern/src/monitor.c
kern/src/process.c
kern/src/resource.c [deleted file]
kern/src/schedule.c

diff --git a/kern/include/resource.h b/kern/include/resource.h
deleted file mode 100644 (file)
index bfa9ca1..0000000
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (c) 2009 The Regents of the University of California
- * Barret Rhoden <brho@cs.berkeley.edu>
- * See LICENSE for details.
- *
- * Kernel resource management.
- */
-
-#ifndef ROS_KERN_RESOURCE_H
-#define ROS_KERN_RESOURCE_H
-
-#include <ros/resource.h>
-#include <error.h>
-#include <ros/common.h>
-#include <arch/trap.h>
-#include <process.h>
-
-bool core_request(struct proc *p);
-
-void print_resources(struct proc *p);
-void print_all_resources(void);
-
-#endif // !ROS_KERN_RESOURCE_H
index 2d1e7a2..0575957 100644 (file)
@@ -30,11 +30,10 @@ void put_idle_core(uint32_t coreid);
 /* How many vcores p will think it can have */
 uint32_t max_vcores(struct proc *p);
 
-/* P wants some cores.  Put them in pc_arr */
-uint32_t proc_wants_cores(struct proc *p, uint32_t *pc_arr, uint32_t amt_new);
-
 /* Debugging */
 void sched_diag(void);
 void print_idlecoremap(void);
+void print_resources(struct proc *p);
+void print_all_resources(void);
 
 #endif /* ROS_KERN_SCHEDULE_H */
index 8b7ab5c..35dda58 100644 (file)
@@ -40,7 +40,6 @@ KERN_SRCFILES := $(KERN_ARCH_SRCFILES) \
                  $(KERN_SRC_DIR)/hashtable.c \
                  $(KERN_SRC_DIR)/schedule.c \
                  $(KERN_SRC_DIR)/mm.c \
-                 $(KERN_SRC_DIR)/resource.c \
                  $(KERN_SRC_DIR)/slab.c \
                  $(KERN_SRC_DIR)/elf.c \
                  $(KERN_SRC_DIR)/frontend.c \
index 32d9aa5..7ad8296 100644 (file)
@@ -26,7 +26,6 @@
 #include <kfs.h>
 #include <stdio.h>
 #include <time.h>
-#include <resource.h>
 #include <monitor.h>
 #include <colored_caches.h>
 #include <string.h>
index 9ec6c36..1672125 100644 (file)
@@ -20,7 +20,6 @@
 #include <testing.h>
 #include <manager.h>
 #include <schedule.h>
-#include <resource.h>
 #include <kdebug.h>
 #include <syscall.h>
 #include <kmalloc.h>
index 6240825..02a90f1 100644 (file)
@@ -25,7 +25,6 @@
 #include <sys/queue.h>
 #include <frontend.h>
 #include <monitor.h>
-#include <resource.h>
 #include <elf.h>
 #include <arsc_server.h>
 #include <devfs.h>
diff --git a/kern/src/resource.c b/kern/src/resource.c
deleted file mode 100644 (file)
index 678c4a6..0000000
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * Copyright (c) 2009 The Regents of the University of California
- * Barret Rhoden <brho@cs.berkeley.edu>
- * See LICENSE for details.
- *
- * Kernel resource management.
- */
-
-#ifdef __IVY__
-#pragma nosharc
-#endif
-
-#include <resource.h>
-#include <process.h>
-#include <smp.h>
-#include <stdio.h>
-#include <assert.h>
-#include <schedule.h>
-#include <hashtable.h>
-
-/* This deals with a request for more cores.  The request is already stored in
- * the proc's amt_wanted (it is compared to amt_granted). 
- *
- * It doesn't take the amount requested directly to avoid a race (or holding the
- * proc_lock across the call), and allowing it to be called in other situations,
- * such as if there was not a new request, but it's time to look at the
- * difference between amt_wanted and amt_granted (maybe on a timer interrupt).
- *
- * Will return either the number actually granted or an error code.  This will
- * not decrease the actual amount of cores (e.g. from 5 to 2), but it will
- * transition a process from _M to _S (amt_wanted == 0).
- *
- * This needs a consumable/edible reference of p, in case it doesn't return.
- */
-bool core_request(struct proc *p)
-{
-       uint32_t num_granted, amt_new, amt_wanted, amt_granted;
-       uint32_t corelist[MAX_NUM_CPUS]; /* TODO UGH, this could be huge! */
-
-       /* Currently, this is all locked, and there's a variety of races involved,
-        * esp with moving amt_wanted to procdata (TODO).  Will probably want to
-        * copy-in amt_wanted too. */
-       spin_lock(&p->proc_lock);
-       amt_wanted = p->procdata->res_req[RES_CORES].amt_wanted;
-       amt_granted = p->procinfo->res_grant[RES_CORES];
-
-       /* Help them out - if they ask for something impossible, give them 1 so they
-        * can make some progress. (these two are racy). */
-       if (amt_wanted > p->procinfo->max_vcores) {
-               p->procdata->res_req[RES_CORES].amt_wanted = 1;
-       }
-       /* TODO: sort how this works with WAITING. */
-       if (!amt_wanted) {
-               p->procdata->res_req[RES_CORES].amt_wanted = 1;
-       }
-       /* if they are satisfied, we're done.  There's a slight chance they have
-        * cores, but they aren't running (sched gave them cores while they were
-        * yielding, and now we see them on the run queue). */
-       if (amt_wanted <= amt_granted) {
-               if (amt_granted) {
-                       spin_unlock(&p->proc_lock);
-                       return TRUE;
-               } else {
-                       spin_unlock(&p->proc_lock);
-                       return FALSE;
-               }
-       }
-       /* otherwise, see what they want.  Current models are simple - it's just a
-        * raw number of cores, and we just give out what we can. */
-       amt_new = amt_wanted - amt_granted;
-       /* TODO: Could also consider amt_min */
-
-       /* TODO: change this.  this function is really "find me amt_new cores", the
-        * nature of this info depends on how we express desires, and a lot of that
-        * info could be lost through this interface. */
-       num_granted = proc_wants_cores(p, corelist, amt_new);
-
-       /* Now, actually give them out */
-       if (num_granted) {
-               /* give them the cores.  this will start up the extras if RUNNING_M. */
-               __proc_give_cores(p, corelist, num_granted);
-               /* at some point after giving cores, call proc_run_m() (harmless on
-                * RUNNING_Ms).  You can give small groups of cores, then run them
-                * (which is more efficient than interleaving runs with the gives for
-                * bulk preempted processes). */
-               __proc_run_m(p); /* harmless to call this on RUNNING_Ms */
-               spin_unlock(&p->proc_lock);
-               return TRUE;    /* proc can run (if it isn't already) */
-       }
-       spin_unlock(&p->proc_lock);
-       return FALSE;           /* Not giving them anything more */
-}
-
-void print_resources(struct proc *p)
-{
-       printk("--------------------\n");
-       printk("PID: %d\n", p->pid);
-       printk("--------------------\n");
-       for (int i = 0; i < MAX_NUM_RESOURCES; i++)
-               printk("Res type: %02d, amt wanted: %08d, amt granted: %08d\n", i,
-                      p->procdata->res_req[i].amt_wanted, p->procinfo->res_grant[i]);
-}
-
-void print_all_resources(void)
-{
-       /* Hash helper */
-       void __print_resources(void *item)
-       {
-               print_resources((struct proc*)item);
-       }
-       spin_lock(&pid_hash_lock);
-       hash_for_each(pid_hash, __print_resources);
-       spin_unlock(&pid_hash_lock);
-}
index 63da8de..dea6535 100644 (file)
@@ -14,7 +14,6 @@
 #include <stdio.h>
 #include <assert.h>
 #include <atomic.h>
-#include <resource.h>
 #include <smp.h>
 #include <sys/queue.h>
 
@@ -36,6 +35,9 @@ uint32_t idlecoremap[MAX_NUM_CPUS];
 uint32_t num_idlecores = 0;
 uint32_t num_mgmtcores = 1;
 
+/* Helper, defined below */
+static bool core_request(struct proc *p);
+
 void schedule_init(void)
 {
        TAILQ_INIT(&runnable_scps);
@@ -199,9 +201,10 @@ uint32_t max_vcores(struct proc *p)
 #endif /* __CONFIG_DISABLE_SMT__ */
 }
 
-/* Ghetto old interface, hacked out of resource.c.  It doesn't even care about
- * the proc yet, but in general the whole core_request bit needs reworked. */
-uint32_t proc_wants_cores(struct proc *p, uint32_t *pc_arr, uint32_t amt_new)
+/* Ghetto helper, just hands out the next amt_new cores, or 0 if we can't do all
+ * of them. */
+static uint32_t get_idle_cores(struct proc *p, uint32_t *pc_arr,
+                               uint32_t amt_new)
 {
        uint32_t num_granted;
        /* You should do something smarter than just giving the stuff out.  Like
@@ -222,6 +225,67 @@ uint32_t proc_wants_cores(struct proc *p, uint32_t *pc_arr, uint32_t amt_new)
        return num_granted;
 }
 
+/* This deals with a request for more cores.  The request is already stored in
+ * the proc's amt_wanted (it is compared to amt_granted). */
+static bool core_request(struct proc *p)
+{
+       uint32_t num_granted, amt_new, amt_wanted, amt_granted;
+       uint32_t corelist[MAX_NUM_CPUS]; /* TODO UGH, this could be huge! */
+
+       /* Currently, this is all locked, and there's a variety of races involved,
+        * esp with moving amt_wanted to procdata (TODO).  Will probably want to
+        * copy-in amt_wanted too. */
+       spin_lock(&p->proc_lock);
+       amt_wanted = p->procdata->res_req[RES_CORES].amt_wanted;
+       amt_granted = p->procinfo->res_grant[RES_CORES];
+
+       /* Help them out - if they ask for something impossible, give them 1 so they
+        * can make some progress. (these two are racy). */
+       if (amt_wanted > p->procinfo->max_vcores) {
+               p->procdata->res_req[RES_CORES].amt_wanted = 1;
+       }
+       /* TODO: sort how this works with WAITING. */
+       if (!amt_wanted) {
+               p->procdata->res_req[RES_CORES].amt_wanted = 1;
+       }
+       /* if they are satisfied, we're done.  There's a slight chance they have
+        * cores, but they aren't running (sched gave them cores while they were
+        * yielding, and now we see them on the run queue). */
+       if (amt_wanted <= amt_granted) {
+               if (amt_granted) {
+                       spin_unlock(&p->proc_lock);
+                       return TRUE;
+               } else {
+                       spin_unlock(&p->proc_lock);
+                       return FALSE;
+               }
+       }
+       /* otherwise, see what they want.  Current models are simple - it's just a
+        * raw number of cores, and we just give out what we can. */
+       amt_new = amt_wanted - amt_granted;
+       /* TODO: Could also consider amt_min */
+
+       /* TODO: change this.  this function is really "find me amt_new cores", the
+        * nature of this info depends on how we express desires, and a lot of that
+        * info could be lost through this interface. */
+       num_granted = get_idle_cores(p, corelist, amt_new);
+
+       /* Now, actually give them out */
+       if (num_granted) {
+               /* give them the cores.  this will start up the extras if RUNNING_M. */
+               __proc_give_cores(p, corelist, num_granted);
+               /* at some point after giving cores, call proc_run_m() (harmless on
+                * RUNNING_Ms).  You can give small groups of cores, then run them
+                * (which is more efficient than interleaving runs with the gives for
+                * bulk preempted processes). */
+               __proc_run_m(p); /* harmless to call this on RUNNING_Ms */
+               spin_unlock(&p->proc_lock);
+               return TRUE;    /* proc can run (if it isn't already) */
+       }
+       spin_unlock(&p->proc_lock);
+       return FALSE;           /* Not giving them anything more */
+}
+
 /************** Debugging **************/
 void sched_diag(void)
 {
@@ -241,3 +305,25 @@ void print_idlecoremap(void)
                printk("idlecoremap[%d] = %d\n", i, idlecoremap[i]);
        spin_unlock(&idle_lock);
 }
+
+void print_resources(struct proc *p)
+{
+       printk("--------------------\n");
+       printk("PID: %d\n", p->pid);
+       printk("--------------------\n");
+       for (int i = 0; i < MAX_NUM_RESOURCES; i++)
+               printk("Res type: %02d, amt wanted: %08d, amt granted: %08d\n", i,
+                      p->procdata->res_req[i].amt_wanted, p->procinfo->res_grant[i]);
+}
+
+void print_all_resources(void)
+{
+       /* Hash helper */
+       void __print_resources(void *item)
+       {
+               print_resources((struct proc*)item);
+       }
+       spin_lock(&pid_hash_lock);
+       hash_for_each(pid_hash, __print_resources);
+       spin_unlock(&pid_hash_lock);
+}