HardwareThreadScheduler.h

Go to the documentation of this file.

/* ========================================
 
  Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
 
======================================== */
 
#ifndef __INC_MP_MANAGER_H__
#define __INC_MP_MANAGER_H__
 
#include <ArchKit/ArchKit.h>
#include <CompilerKit/CompilerKit.h>
#include <NeKit/Ref.h>

 
#define kMaxAPInsideSched (4U)
 
namespace Kernel {
class HardwareThread;
class HardwareThreadScheduler;
 
using ThreadID = UInt32;
 
enum ThreadKind {
  kAPInvalid        = 0,
  kAPSystemReserved = 100,  // System reserved thread, well user can't use it
  kAPStandard,              // user thread, cannot be used by Kernel
  kAPRealTime,              // fallback thread, cannot be used by user if not clear or
                            // used by Kernel.
  kAPBoot,                  // The core we booted from, the mama.
  kAPCount,
};
 
typedef enum ThreadKind ThreadKind;
typedef ThreadID        ThreadID;
 
/***********************************************************************************/
/***********************************************************************************/
 
class HardwareThread final {
 public:
  explicit HardwareThread();
  ~HardwareThread();
 
 public:
  NE_COPY_DEFAULT(HardwareThread)
 
 public:
  operator bool();
 
 public:
  void Wake(const BOOL wakeup = false);
  void Busy(const BOOL busy = false);
 
 public:
  BOOL Switch(HAL::StackFramePtr frame);
  BOOL IsWakeup();
 
 public:
  HAL::StackFramePtr StackFrame();
  ThreadKind&        Kind();
  BOOL               IsBusy();
  ThreadID&          ID();
 
 private:
  HAL::StackFramePtr fStack{nullptr};
  ThreadKind         fKind{ThreadKind::kAPStandard};
  ThreadID           fID{0};
  Bool               fWakeup{NO};
  Bool               fBusy{NO};
  UInt64             fPTime{0};
 
 private:
  friend class HardwareThreadScheduler;
  friend class UserProcessHelper;
};

 
class HardwareThreadScheduler final : public ISchedulable {
 private:
  friend class UserProcessHelper;
 
 public:
  explicit HardwareThreadScheduler();
  ~HardwareThreadScheduler();
  NE_COPY_DEFAULT(HardwareThreadScheduler)
 
 public:
  HAL::StackFramePtr Leak();
 
 public:
  Ref<HardwareThread*> operator[](SizeT idx);
  bool                 operator!();
  operator bool();
 
  Bool IsUser() override { return Yes; }
 
  Bool IsKernel() override { return No; }
 
  Bool HasMP() override { return kHandoverHeader->f_HardwareTables.f_MultiProcessingEnabled; }
 
 public:
  STATIC HardwareThreadScheduler& The();
 
 public:
  SizeT Capacity();
 
 private:
  Array<HardwareThread, kMaxAPInsideSched> fThreadList;
  ThreadID                                 fCurrentThreadIdx{0};
};

Void mp_wakeup_thread(HAL::StackFramePtr stack);

Void mp_hang_thread(HAL::StackFramePtr stack);
}  // namespace Kernel
 
#endif  // !__INC_MP_MANAGER_H__