smp: Structures for running tasks on a specific CPU

Author: fwsGonzo

api/smp

@@ -114,11 +114,13 @@ public:
   // execute @func on another CPU core
   // call @done back on main CPU when task returns
   // use signal() to broadcast work should begin
-  static void add_task(task_func func, done_func done);
-  static void add_task(task_func func);
+  static void add_task(task_func func, done_func done, int cpu = -1);
+  static void add_task(task_func func, int cpu = -1);
+  // execute a function on the main cpu
+  static void add_bsp_task(done_func func);
 
   // call this to signal that tasks are queued up
-  static void signal();
+  static void signal(int cpu = -1);
 
   // trigger interrupt on specified CPU
   static void unicast(int cpu, uint8_t intr);

src/platform/x86_pc/apic_revenant.cpp

@@ -3,6 +3,7 @@
 #include "apic.hpp"
 #include "apic_timer.hpp"
 #include <kernel/irq_manager.hpp>
+#include <kernel/rng.hpp>
 #include <kprint>
 
 extern "C" int    get_cpu_id();
@@ -12,30 +13,32 @@ extern "C" void   lapic_exception_handler();
 
 using namespace x86;
 smp_stuff smp;
+SMP_ARRAY<smp_stuff> smp_local;
 
-static bool revenant_task_doer()
+static bool revenant_task_doer(smp_stuff& system)
 {
   // grab hold on task list
-  lock(smp.tlock);
+  lock(system.tlock);
 
-  if (smp.tasks.empty()) {
-    unlock(smp.tlock);
+  if (system.tasks.empty()) {
+    unlock(system.tlock);
     // try again
     return false;
   }
 
   // get copy of shared task
-  auto task = std::move(smp.tasks.front());
-  smp.tasks.pop_front();
+  auto task = std::move(system.tasks.front());
+  system.tasks.pop_front();
 
-  unlock(smp.tlock);
+  unlock(system.tlock);
 
   // execute actual task
   task.func();
 
   // add done function to completed list (only if its callable)
   if (task.done)
   {
+    // NOTE: specifically pushing to 'smp' here, and not 'system'
     lock(smp.flock);
     smp.completed.push_back(std::move(task.done));
     unlock(smp.flock);
@@ -48,7 +51,11 @@ static void revenant_task_handler()
 {
   bool work_done = false;
   while (true) {
-    bool did_something = revenant_task_doer();
+    // global tasks
+    bool did_something = revenant_task_doer(smp);
+    work_done = work_done || did_something;
+    // cpu-specific tasks
+    did_something = revenant_task_doer(PER_CPU(smp_local));
     work_done = work_done || did_something;
     if (did_something == false) break;
   }
@@ -74,9 +81,11 @@ void revenant_main(int cpu)
   IRQ_manager::enable_interrupts();
   // init timer system
   APIC_Timer::init();
-
+  // subscribe to task and timer interrupts
   IRQ_manager::get().subscribe(0, revenant_task_handler);
   IRQ_manager::get().subscribe(1, APIC_Timer::start_timers);
+  // seed RNG
+  RNG::init();
 
   // allow programmers to do stuff on each core at init
   ::SMP::init_task();

src/platform/x86_pc/apic_revenant.hpp

@@ -45,5 +45,6 @@ struct smp_stuff
   std::deque<SMP::done_func> completed;
 };
 extern smp_stuff smp;
+extern SMP_ARRAY<smp_stuff> smp_local;
 
 #endif

src/platform/x86_pc/smp.cpp

@@ -151,31 +151,69 @@ void ::SMP::init_task()
   /* do nothing */
 }
 
-void ::SMP::add_task(smp_task_func task, smp_done_func done)
+void ::SMP::add_task(smp_task_func task, smp_done_func done, int cpu)
 {
 #ifdef INCLUDEOS_SINGLE_THREADED
+  assert(cpu == -1 || cpu == 0);
   task(); done();
 #else
-  lock(smp.tlock);
-  smp.tasks.emplace_back(std::move(task), std::move(done));
-  unlock(smp.tlock);
+  if (cpu == -1)
+  {
+    lock(smp.tlock);
+    smp.tasks.emplace_back(std::move(task), std::move(done));
+    unlock(smp.tlock);
+  }
+  else {
+    lock(smp_local[cpu].tlock);
+    smp_local[cpu].tasks.emplace_back(std::move(task), std::move(done));
+    unlock(smp_local[cpu].tlock);
+  }
 #endif
 }
-void ::SMP::add_task(smp_task_func task)
+void ::SMP::add_task(smp_task_func task, int cpu)
 {
 #ifdef INCLUDEOS_SINGLE_THREADED
+  assert(cpu == -1 || cpu == 0);
   task();
 #else
-  lock(smp.tlock);
-  smp.tasks.emplace_back(std::move(task), nullptr);
-  unlock(smp.tlock);
+  if (cpu == -1)
+  {
+    lock(smp.tlock);
+    smp.tasks.emplace_back(std::move(task), nullptr);
+    unlock(smp.tlock);
+  }
+  else {
+    lock(smp_local[cpu].tlock);
+    smp_local[cpu].tasks.emplace_back(std::move(task), nullptr);
+    unlock(smp_local[cpu].tlock);
+  }
 #endif
 }
-void ::SMP::signal()
+void ::SMP::add_bsp_task(smp_done_func task)
+{
+#ifdef INCLUDEOS_SINGLE_THREADED
+  task();
+#else
+  lock(smp.flock);
+  smp.completed.push_back(std::move(task));
+  unlock(smp.flock);
+  x86::APIC::get().send_bsp_intr();
+#endif
+}
+
+void ::SMP::signal(int cpu)
 {
 #ifndef INCLUDEOS_SINGLE_THREADED
   // broadcast that there is work to do
-  x86::APIC::get().bcast_ipi(0x20);
+  // -1: Broadcast to everyone except BSP
+  if (cpu == -1)
+      x86::APIC::get().bcast_ipi(0x20);
+  // 1-xx: Unicast specific vCPU
+  else if (cpu != 0)
+      x86::APIC::get().send_ipi(cpu, 0x20);
+  // 0: BSP unicast
+  else
+      x86::APIC::get().send_bsp_intr();
 #endif
 }