prof: samples userspace PCs
[akaros.git] / kern / src / schedule.c
index a229b5d..ad7ab6c 100644 (file)
@@ -100,7 +100,7 @@ static void set_ksched_alarm(void)
 /* Need a kmsg to just run the sched, but not to rearm */
 static void __just_sched(uint32_t srcid, long a0, long a1, long a2)
 {
-       schedule();
+       run_scheduler();
 }
 
 /* Kmsg, to run the scheduler tick (not in interrupt context) and reset the
@@ -110,7 +110,7 @@ static void __just_sched(uint32_t srcid, long a0, long a1, long a2)
 static void __ksched_tick(uint32_t srcid, long a0, long a1, long a2)
 {
        /* TODO: imagine doing some accounting here */
-       schedule();
+       run_scheduler();
        /* Set our alarm to go off, incrementing from our last tick (instead of
         * setting it relative to now, since some time has passed since the alarm
         * first went off.  Note, this may be now or in the past! */
@@ -122,6 +122,8 @@ static void __ksched_tick(uint32_t srcid, long a0, long a1, long a2)
  * interrupt context). */
 static void __kalarm(struct alarm_waiter *waiter)
 {
+       /* Not necessary when alarms are running in RKM context (check
+        * timer_interrupt()) */
        send_kernel_message(core_id(), __ksched_tick, 0, 0, 0, KMSG_ROUTINE);
 }
 
@@ -137,15 +139,15 @@ void schedule_init(void)
        /* init the idlecore list.  if they turned off hyperthreading, give them the
         * odds from 1..max-1.  otherwise, give them everything by 0 (default mgmt
         * core).  TODO: (CG/LL) better LL/CG mgmt */
-#ifndef __CONFIG_DISABLE_SMT__
+#ifndef CONFIG_DISABLE_SMT
        for (int i = 1; i < num_cpus; i++)
                TAILQ_INSERT_TAIL(&idlecores, pcoreid2spc(i), alloc_next);
 #else
        assert(!(num_cpus % 2));
        for (int i = 1; i < num_cpus; i += 2)
                TAILQ_INSERT_TAIL(&idlecores, pcoreid2spc(i), alloc_next);
-#endif /* __CONFIG_DISABLE_SMT__ */
-#ifdef __CONFIG_ARSC_SERVER__
+#endif /* CONFIG_DISABLE_SMT */
+#ifdef CONFIG_ARSC_SERVER
        struct sched_pcore *a_core = TAILQ_FIRST(&idlecores);
        assert(a_core);
        TAILQ_REMOVE(&idlecores, a_core, alloc_next);
@@ -153,7 +155,7 @@ void schedule_init(void)
                            KMSG_ROUTINE);
        warn("Using core %d for the ARSCs - there are probably issues with this.",
             spc2pcoreid(a_core));
-#endif /* __CONFIG_ARSC_SERVER__ */
+#endif /* CONFIG_ARSC_SERVER */
        spin_unlock(&sched_lock);
        return;
 }
@@ -386,6 +388,7 @@ static bool __schedule_scp(void)
                         * IRQ and has a HW ctx, in which case we must save. */
                        __proc_save_fpu_s(pcpui->owning_proc);
                        __proc_save_context_s(pcpui->owning_proc, pcpui->cur_ctx);
+                       vcore_account_offline(pcpui->owning_proc, 0); /* VC# */
                        spin_unlock(&pcpui->owning_proc->proc_lock);
                        /* round-robin the SCPs (inserts at the end of the queue) */
                        switch_lists(pcpui->owning_proc, &unrunnable_scps, &runnable_scps);
@@ -510,8 +513,11 @@ static void __run_mcp_ksched(void *arg)
 /* Something has changed, and for whatever reason the scheduler should
  * reevaluate things. 
  *
+ * Don't call this if you are processing a syscall or otherwise care about your
+ * kthread variables, cur_proc/owning_proc, etc.
+ *
  * Don't call this from interrupt context (grabs proclocks). */
-void schedule(void)
+void run_scheduler(void)
 {
        /* MCP scheduling: post work, then poke.  for now, i just want the func to
         * run again, so merely a poke is sufficient. */
@@ -570,11 +576,11 @@ void avail_res_changed(int res_type, long change)
 uint32_t max_vcores(struct proc *p)
 {
 /* TODO: (CG/LL) */
-#ifdef __CONFIG_DISABLE_SMT__
+#ifdef CONFIG_DISABLE_SMT
        return num_cpus >> 1;
 #else
        return num_cpus - 1;    /* reserving core 0 */
-#endif /* __CONFIG_DISABLE_SMT__ */
+#endif /* CONFIG_DISABLE_SMT */
 }
 
 /* This deals with a request for more cores.  The amt of new cores needed is
@@ -848,7 +854,7 @@ void print_idlecoremap(void)
        /* not locking, so we can look at this without deadlocking. */
        printk("Idle cores (unlocked!):\n");
        TAILQ_FOREACH(spc_i, &idlecores, alloc_next)
-               printk("Core %d, prov to %d (%08p)\n", spc2pcoreid(spc_i),
+               printk("Core %d, prov to %d (%p)\n", spc2pcoreid(spc_i),
                       spc_i->prov_proc ? spc_i->prov_proc->pid : 0, spc_i->prov_proc);
 }
 
@@ -881,7 +887,7 @@ void print_prov_map(void)
        printk("Which cores are provisioned to which procs:\n------------------\n");
        for (int i = 0; i < num_cpus; i++) {
                spc_i = pcoreid2spc(i);
-               printk("Core %02d, prov: %d(%08p) alloc: %d(%08p)\n", i,
+               printk("Core %02d, prov: %d(%p) alloc: %d(%p)\n", i,
                       spc_i->prov_proc ? spc_i->prov_proc->pid : 0, spc_i->prov_proc,
                       spc_i->alloc_proc ? spc_i->alloc_proc->pid : 0,
                       spc_i->alloc_proc);
@@ -893,12 +899,12 @@ void print_proc_prov(struct proc *p)
        struct sched_pcore *spc_i;
        if (!p)
                return;
-       printk("Prov cores alloced to proc %d (%08p)\n----------\n", p->pid, p);
+       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)
                printk("Pcore %d\n", spc2pcoreid(spc_i));
-       printk("Prov cores not alloced to proc %d (%08p)\n----------\n", p->pid, p);
+       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)
-               printk("Pcore %d (alloced to %d (%08p))\n", spc2pcoreid(spc_i),
+               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);
 }