如果覺得文章對你有所啟發，可以考慮用 🌟 支持 Gthulhu 專案，短期目標是集齊 300 個 🌟 藉此被 CNCF Landscape 採納 [ref]。

sched_ext 的衍生物基本上都使用 GPL 授權，因為 GPL 授權較為嚴格，許多公司可能會因為不想揭露其商業機密而不採用 sched_ext 或是 Gthulhu。

為了克服這個問題，我採納了 Jserv 老師的提議，將 Gthulhu 於 User-Space 的核心實作抽離出來，改以更為寬鬆的 Apache 2.0 授權。這讓使用者需要一定程度客製化私有排程器時不需要將修改的部分開放大眾存取。

type CustomScheduler interface {
    // Drain the queued task from eBPF and return the number of tasks drained
    DrainQueuedTask(s Sched) int
    // Select a task from the queued tasks and return it
    SelectQueuedTask(s Sched) *models.QueuedTask
    // Select a CPU for the given queued task, After selecting the CPU, the task will be dispatched to that CPU by Scheduler
    SelectCPU(s Sched, t *models.QueuedTask) (error, int32)
    // Determine the time slice for the given task
    DetermineTimeSlice(s Sched, t *models.QueuedTask) uint64
    // Get the number of objects in the pool (waiting to be dispatched)
    // GetPoolCount will be called by the scheduler to notify the number of tasks waiting to be dispatched (NotifyComplete)
    GetPoolCount() uint64
}

只要滿足以上 interface 的定義，就能替換掉 Gthulhu 的預設排程行為（vtime-based scheduler）。
需要注意的是，上列的幾個 API 需要傳入 Sched instance：

type Sched interface {
    DequeueTask(task *models.QueuedTask)
    DefaultSelectCPU(t *models.QueuedTask) (error, int32)
}

• DequeueTask 由 Gthulhu 實作，負責從 eBPF Map 將待排程的任務取出。
• DefaultSelectCPU 則會呼叫預設的 select cpu hook，這部分可自行替換。

此外，因為將核心實作抽離了，plugin 這個套件本身並不依賴 libbpfgo/scx/libbpf，也不需要 cgo。
這讓測試變得更加容易：

// MockScheduler implements the plugin.Sched interface for testing
type MockScheduler struct {
    taskQueue     []*models.QueuedTask
    queueIndex    int
    cpuAllocated  map[int32]int32 // PID -> CPU mapping
    defaultCPU    int32
    dequeueCount  int
    selectCPUCall int
}

// Compile-time check that MockScheduler implements plugin.Sched
var _ plugin.Sched = (*MockScheduler)(nil)

// NewMockScheduler creates a new mock scheduler for testing
func NewMockScheduler() *MockScheduler {
    return &MockScheduler{
        taskQueue:    make([]*models.QueuedTask, 0),
        queueIndex:   0,
        cpuAllocated: make(map[int32]int32),
        defaultCPU:   0,
    }
}

// EnqueueTask adds a task to the mock scheduler's queue
func (m *MockScheduler) EnqueueTask(task *models.QueuedTask) {
    m.taskQueue = append(m.taskQueue, task)
}

// DequeueTask implements plugin.Sched.DequeueTask
func (m *MockScheduler) DequeueTask(task *models.QueuedTask) {
    m.dequeueCount++
    if m.queueIndex >= len(m.taskQueue) {
        // No more tasks, return sentinel value
        task.Pid = -1
        return
    }

    // Copy the task from queue
    qt := m.taskQueue[m.queueIndex]
    *task = *qt
    m.queueIndex++
}

// DefaultSelectCPU implements plugin.Sched.DefaultSelectCPU
func (m *MockScheduler) DefaultSelectCPU(t *models.QueuedTask) (error, int32) {
    m.selectCPUCall++
    // Simple round-robin CPU selection
    cpu := m.defaultCPU
    m.defaultCPU = (m.defaultCPU + 1) % 4 // Assume 4 CPUs
    m.cpuAllocated[t.Pid] = cpu
    return nil, cpu
}

// Reset resets the mock scheduler state
func (m *MockScheduler) Reset() {
    m.taskQueue = make([]*models.QueuedTask, 0)
    m.queueIndex = 0
    m.cpuAllocated = make(map[int32]int32)
    m.defaultCPU = 0
    m.dequeueCount = 0
    m.selectCPUCall = 0
}

在測試檔案中，我們預先定義好 MockScheduler 的行為，便能夠在沒有 eBPF 程式載入的前提下對 Gthulhu plugin 進行測試：

func TestXXX(t *testing.T) {
    // Create plugin instance
    gthulhuPlugin := NewGthulhuPlugin(5000*1000, 500*1000)

    // Create mock scheduler
    mockSched := NewMockScheduler()

    t.Run("MultipleTasksWorkflow", func(t *testing.T) {
        mockSched.Reset()
        gthulhuPlugin = NewGthulhuPlugin(5000*1000, 500*1000) // Reset plugin

        // Create multiple tasks with different priorities
        tasks := []*models.QueuedTask{
            {Pid: 100, Weight: 100, Vtime: 0, Tgid: 100, StartTs: 1000, StopTs: 2000},
            {Pid: 200, Weight: 150, Vtime: 0, Tgid: 200, StartTs: 1500, StopTs: 2500},
            {Pid: 300, Weight: 80, Vtime: 0, Tgid: 300, StartTs: 2000, StopTs: 3000},
        }

        // Enqueue all tasks
        for _, task := range tasks {
            mockSched.EnqueueTask(task)
        }

        // Drain all tasks
        drained := gthulhuPlugin.DrainQueuedTask(mockSched)
        if drained != 3 {
            t.Errorf("DrainQueuedTask = %d; want 3", drained)
        }

        // Verify pool count
        if gthulhuPlugin.GetPoolCount() != 3 {
            t.Errorf("GetPoolCount = %d; want 3", gthulhuPlugin.GetPoolCount())
        }

        // Process all tasks
        processedTasks := make([]*models.QueuedTask, 0)
        for gthulhuPlugin.GetPoolCount() > 0 {
            task := gthulhuPlugin.SelectQueuedTask(mockSched)
            if task == nil {
                t.Fatal("SelectQueuedTask returned nil while pool count > 0")
            }

            // Select CPU and determine time slice
            err, cpu := gthulhuPlugin.SelectCPU(mockSched, task)
            if err != nil {
                t.Errorf("SelectCPU error: %v", err)
            }
            if cpu < 0 {
                t.Errorf("Invalid CPU selected: %d", cpu)
            }

            _ = gthulhuPlugin.DetermineTimeSlice(mockSched, task)
            processedTasks = append(processedTasks, task)
        }

        // Verify all tasks were processed
        if len(processedTasks) != 3 {
            t.Errorf("Processed tasks = %d; want 3", len(processedTasks))
        }

        // Verify pool is empty
        if gthulhuPlugin.GetPoolCount() != 0 {
            t.Errorf("Final GetPoolCount = %d; want 0", gthulhuPlugin.GetPoolCount())
        }
    })
}

plugin pattern 為 Gthulhu 帶來了多變的靈活性。我們將在下一篇文章中嘗試實作一個簡易的 scheduler！