BCQ touch-ups (XCC)
[akaros.git] / kern / src / schedule.c
index ad7ab6c..ceff708 100644 (file)
@@ -103,11 +103,11 @@ static void __just_sched(uint32_t srcid, long a0, long a1, long a2)
        run_scheduler();
 }
 
-/* Kmsg, to run the scheduler tick (not in interrupt context) and reset the
+/* RKM alarm, to run the scheduler tick (not in interrupt context) and reset the
  * alarm.  Note that interrupts will be disabled, but this is not the same as
  * interrupt context.  We're a routine kmsg, which means the core is in a
  * quiescent state. */
-static void __ksched_tick(uint32_t srcid, long a0, long a1, long a2)
+static void __ksched_tick(struct alarm_waiter *waiter)
 {
        /* TODO: imagine doing some accounting here */
        run_scheduler();
@@ -118,15 +118,6 @@ static void __ksched_tick(uint32_t srcid, long a0, long a1, long a2)
        set_alarm(&per_cpu_info[core_id()].tchain, &ksched_waiter);
 }
 
-/* Interrupt/alarm handler: tells our core to run the scheduler (out of
- * 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);
-}
-
 void schedule_init(void)
 {
        spin_lock(&sched_lock);
@@ -134,7 +125,7 @@ void schedule_init(void)
        all_pcores = kmalloc(sizeof(struct sched_pcore) * num_cpus, 0);
        memset(all_pcores, 0, sizeof(struct sched_pcore) * num_cpus);
        assert(!core_id());             /* want the alarm on core0 for now */
-       init_awaiter(&ksched_waiter, __kalarm);
+       init_awaiter(&ksched_waiter, __ksched_tick);
        set_ksched_alarm();
        /* 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
@@ -313,6 +304,23 @@ void __sched_scp_wakeup(struct proc *p)
        remove_from_any_list(p);
        add_to_list(p, &runnable_scps);
        spin_unlock(&sched_lock);
+       /* we could be on a CG core, and all the mgmt cores could be halted.  if we
+        * don't tell one of them about the new proc, they will sleep until the
+        * timer tick goes off. */
+       if (!management_core()) {
+               /* TODO: pick a better core and only send if halted.
+                *
+                * FYI, a POKE on x86 might lose a rare race with halt code, since the
+                * poke handler does not abort halts.  if this happens, the next timer
+                * IRQ would wake up the core.
+                *
+                * ideally, we'd know if a specific mgmt core is sleeping and wake it
+                * up.  o/w, we could interrupt an already-running mgmt core that won't
+                * get to our new proc anytime soon.  also, by poking core 0, a
+                * different mgmt core could remain idle (and this process would sleep)
+                * until its tick goes off */
+               send_ipi(0, I_POKE_CORE);
+       }
 }
 
 /* Callback to return a core to the ksched, which tracks it as idle and
@@ -927,3 +935,27 @@ void next_core(uint32_t pcoreid)
        }
        spin_unlock(&sched_lock);
 }
+
+void sort_idles(void)
+{
+       struct sched_pcore *spc_i, *spc_j, *temp;
+       struct sched_pcore_tailq sorter = TAILQ_HEAD_INITIALIZER(sorter);
+       bool added;
+       spin_lock(&sched_lock);
+       TAILQ_CONCAT(&sorter, &idlecores, alloc_next);
+       TAILQ_FOREACH_SAFE(spc_i, &sorter, alloc_next, temp) {
+               TAILQ_REMOVE(&sorter, spc_i, alloc_next);
+               added = FALSE;
+               /* don't need foreach_safe since we break after we muck with the list */
+               TAILQ_FOREACH(spc_j, &idlecores, alloc_next) {
+                       if (spc_i < spc_j) {
+                               TAILQ_INSERT_BEFORE(spc_j, spc_i, alloc_next);
+                               added = TRUE;
+                               break;
+                       }
+               }
+               if (!added)
+                       TAILQ_INSERT_TAIL(&idlecores, spc_i, alloc_next);
+       }
+       spin_unlock(&sched_lock);
+}