task_manager.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cpu_io.h>
#include <etl/list.h>
#include <etl/memory.h>
#include <etl/priority_queue.h>
#include <etl/singleton.h>
#include <etl/unordered_map.h>
#include <etl/vector.h>
 
#include <MPMCQueue.hpp>
#include <array>
#include <cstddef>
#include <cstdint>
 
#include "expected.hpp"
#include "interrupt_base.h"
#include "kernel_config.hpp"
#include "kstd_memory"
#include "per_cpu.hpp"
#include "resource_id.hpp"
#include "scheduler_base.hpp"
#include "spinlock.hpp"
#include "task_control_block.hpp"
 
struct CpuSchedData {
  SpinLock lock{"sched_lock"};
 
  std::array<etl::unique_ptr<SchedulerBase>,
             static_cast<uint8_t>(SchedPolicy::kPolicyCount)>
      schedulers{};
 
  etl::priority_queue<
      TaskControlBlock*, kernel::config::kMaxSleepingTasks,
      etl::vector<TaskControlBlock*, kernel::config::kMaxSleepingTasks>,
      TaskControlBlock::WakeTickCompare>
      sleeping_tasks;
 
  etl::unordered_map<
      ResourceId,
      etl::list<TaskControlBlock*, kernel::config::kMaxBlockedPerGroup>,
      kernel::config::kMaxBlockedGroups,
      kernel::config::kMaxBlockedGroupsBuckets>
      blocked_tasks;
 
  uint64_t local_tick{0};
 
  uint64_t idle_time{0};
 
  uint64_t total_schedules{0};
 
  bool scheduler_started{false};
 
  CpuSchedData() = default;
  CpuSchedData(const CpuSchedData&) = delete;
  CpuSchedData(CpuSchedData&&) = delete;
  auto operator=(const CpuSchedData&) -> CpuSchedData& = delete;
  auto operator=(CpuSchedData&&) -> CpuSchedData& = delete;
  ~CpuSchedData() = default;
};
 
class TaskManager {
 public:
  auto InitCurrentCore() -> void;
 
  auto AddTask(etl::unique_ptr<TaskControlBlock> task) -> void;
 
  auto Schedule() -> void;
 
  [[nodiscard]] auto GetCurrentTask() const -> TaskControlBlock* {
    return per_cpu::GetCurrentCore().running_task;
  }
 
  auto TickUpdate() -> void;
 
  auto Sleep(uint64_t ms) -> void;
 
  [[noreturn]] auto Exit(int exit_code = 0) -> void;
 
  auto Block(ResourceId resource_id) -> void;
 
  auto Wakeup(ResourceId resource_id) -> void;
 
  [[nodiscard]] auto Clone(uint64_t flags, void* user_stack, int* parent_tid,
                           int* child_tid, void* tls,
                           cpu_io::TrapContext& parent_context)
      -> Expected<Pid>;
 
  [[nodiscard]] auto Wait(Pid pid, int* status, bool no_hang = false,
                          bool untraced = false) -> Expected<Pid>;
 
  [[nodiscard]] auto FindTask(Pid pid) -> TaskControlBlock*;
 
  TaskManager() = default;
  TaskManager(const TaskManager&) = delete;
  TaskManager(TaskManager&&) = delete;
  auto operator=(const TaskManager&) -> TaskManager& = delete;
  auto operator=(TaskManager&&) -> TaskManager& = delete;
  ~TaskManager();
 
 private:
  static constexpr size_t kInterruptQueueCapacity = 256;
 
  struct InterruptWork {
    using WorkHandler = void (*)(InterruptWork*);
 
    uint64_t interrupt_no{0};
    cpu_io::TrapContext* data{nullptr};
    uint64_t timestamp{0};
 
    WorkHandler handler{nullptr};
  };
 
  using InterruptWorkQueue =
      mpmc_queue::MPMCQueue<InterruptWork, kInterruptQueueCapacity>;
 
  std::array<CpuSchedData, SIMPLEKERNEL_MAX_CORE_COUNT> cpu_schedulers_{};
 
  SpinLock task_table_lock_{"task_table_lock"};
  etl::unordered_map<Pid, etl::unique_ptr<TaskControlBlock>,
                     kernel::config::kMaxTasks,
                     kernel::config::kMaxTasksBuckets>
      task_table_;
 
  SpinLock interrupt_threads_lock_{"interrupt_threads_lock"};
  etl::unordered_map<uint64_t, TaskControlBlock*,
                     kernel::config::kMaxInterruptThreads,
                     kernel::config::kMaxInterruptThreadsBuckets>
      interrupt_threads_;
  etl::unordered_map<uint64_t, InterruptWorkQueue*,
                     kernel::config::kMaxInterruptThreads,
                     kernel::config::kMaxInterruptThreadsBuckets>
      interrupt_work_queues_;
 
  std::atomic<size_t> pid_allocator_{1};
 
  [[nodiscard]] auto AllocatePid() -> size_t;
 
  auto Balance() -> void;
 
  [[nodiscard]] auto GetCurrentCpuSched() -> CpuSchedData& {
    return cpu_schedulers_[cpu_io::GetCurrentCoreId()];
  }
 
  auto GetThreadGroup(Pid tgid)
      -> etl::vector<TaskControlBlock*, kernel::config::kMaxReadyTasks>;
 
  auto SignalThreadGroup(Pid tgid, int signal) -> void;
 
  auto ReapTask(TaskControlBlock* task) -> void;
 
  auto ReparentChildren(TaskControlBlock* parent) -> void;
};
 
using TaskManagerSingleton = etl::singleton<TaskManager>;