리눅스 커널 스케줄러: sched_class 구조와 프로세스 스케줄링 전략

리눅스 커널 프로세스 스케줄링 심층 분석

리눅스 커널의 task_struct 구조체 내에서 프로세스의 현재 상태를 나타내는 state 필드와 더불어, sched_class 포인터는 해당 프로세스가 어떤 스케줄링 정책에 따라 CPU 시간을 할당받을지 정의하는 핵심 요소입니다. 이 글에서는 sched_class의 역할과 리눅스 커널이 다양한 스케줄러 클래스를 통해 프로세스들을 어떻게 관리하는지 자세히 살펴보겠습니다.

const struct sched_class	*sched_class;
struct sched_entity		se;
struct sched_rt_entity		rt;
struct sched_dl_entity		dl;

위 task_struct의 일부 필드들은 프로세스 스케줄링과 직접적으로 관련되어 있으며, 그 중 sched_class는 특정 프로세스에 적용될 스케줄러 클래스를 가리킵니다.

sched_class 구조체의 이해

struct sched_class는 kernel/sched/sched.h에 정의되어 있으며, 커널의 프로세스 스케줄링 메커니즘을 추상화하는 중요한 구조체입니다. 이 구조체는 각 스케줄러 클래스가 구현해야 할 표준화된 인터페이스, 즉 일련의 함수 포인터들을 포함하고 있습니다. 이를 통해 커널은 다양한 스케줄링 정책을 유연하게 통합할 수 있습니다.

struct sched_class {
    void (*enqueue_task) (struct rq *rq, struct task_struct *p, int flags);
    void (*dequeue_task) (struct rq *rq, struct task_struct *p, int flags);
    void (*yield_task)   (struct rq *rq);
    bool (*yield_to_task)(struct rq *rq, struct task_struct *p);
    void (*check_preempt_curr)(struct rq *rq, struct task_struct *p, int flags);
    struct task_struct *(*pick_next_task)(struct rq *rq);
    // ... 추가 함수 포인터들
};

sched_class의 주요 함수 포인터들이 수행하는 역할은 다음과 같습니다:

  • enqueue_task: 프로세스가 "실행 가능" 상태(TASK_RUNNING)가 되어 스케줄링 대기열에 진입할 때 호출됩니다. 이 함수는 프로세스를 해당 스케줄러 클래스의 대기열(예: CFS의 레드-블랙 트리, RT의 우선순위 큐)에 추가하고 관련 통계를 업데이트합니다. 프로세스 깨어나기, CPU 간 부하 분산에 따른 마이그레이션, sched_yield() 호출 후 재진입 등의 상황에서 활용됩니다.
  • dequeue_task: 프로세스가 "실행 가능" 상태를 벗어나 스케줄링 대기열에서 제거될 때 호출됩니다. 프로세스가 블록되거나, 종료되거나, 다른 CPU로 이동할 때 이 함수를 통해 대기열에서 제거되고 통계가 갱신됩니다.
  • yield_task: 프로세스가 sched_yield() 시스템 호출을 통해 자발적으로 CPU를 양보할 때 사용됩니다. 이 함수는 프로세스를 대기열의 상대적으로 낮은 우선순위 위치에 다시 삽입하고, 즉시 새로운 스케줄링을 트리거하여 다른 프로세스가 CPU를 사용할 기회를 줍니다. 주로 백그라운드 배치 작업과 같이 비긴급 작업에서 CPU를 양보하는 데 활용됩니다.
  • pick_next_task: 스케줄러가 schedule() 함수를 실행하여 다음에 실행할 프로세스를 선택할 때 호출되는 가장 중요한 함수입니다. 이 함수는 현재 CPU의 실행 대기열(run queue, rq)에서 스케줄링 정책에 따라 가장 적합한 프로세스를 찾아 반환합니다. 주기적인 타이머 인터럽트, 프로세스의 자발적인 CPU 양보, 고우선순위 프로세스의 깨어남 등 다양한 스케줄링 시점에서 호출됩니다.

리눅스 커널의 기본 스케줄러 클래스

리눅스 커널은 위 sched_class 구조체를 기반으로 다양한 스케줄링 정책을 구현하는 여러 기본 스케줄러 인스턴스들을 정의합니다. 각 스케줄러는 고유한 스케줄링 알고리즘과 우선순위를 가지며, kernel/sched/sched.h에 다음과 같이 선언되어 있습니다.

extern const struct sched_class stop_sched_class;
extern const struct sched_class dl_sched_class;
extern const struct sched_class rt_sched_class;
extern const struct sched_class fair_sched_class;
extern const struct sched_class idle_sched_class;

task_struct 내의 sched_class 포인터는 이들 중 하나의 const 인스턴스를 가리키게 되며, 이는 프로세스의 스케줄링 정책이 초기화 시점에 결정되고 고정됨을 의미합니다.

스케줄러 클래스 정의 매크로

커널 내부에서는 각 스케줄러 클래스 인스턴스를 정의하기 위해 DEFINE_SCHED_CLASS 매크로를 사용합니다. 이 매크로는 각 클래스가 링커 스크립트에 의해 특정 섹션에 배치되고 적절한 메모리 정렬을 보장하도록 돕습니다.

#define DEFINE_SCHED_CLASS(name) \
const struct sched_class name##_sched_class \
    __aligned(__alignof__(struct sched_class)) \
    __section("__" #name "_sched_class")

예를 들어, CFS 스케줄러(Completely Fair Scheduler)의 fair_sched_class는 다음과 같이 정의됩니다.

DEFINE_SCHED_CLASS(fair) = {
    .enqueue_task       = enqueue_task_fair,
    .dequeue_task       = dequeue_task_fair,
    .yield_task         = yield_task_fair,
    .yield_to_task      = yield_to_task_fair,
    .check_preempt_curr = check_preempt_wakeup,
    .pick_next_task     = __pick_next_task_fair,
    .put_prev_task      = put_prev_task_fair,
    .set_next_task      = set_next_task_fair,
    // ...
};

이와 같이 각 스케줄러 클래스는 sched_class 구조체의 함수 포인터들을 자신의 고유한 스케줄링 로직을 담은 함수들로 채워 넣습니다.

스케줄러 클래스의 우선순위와 적용 시나리오

리눅스 커널은 스케줄러 클래스들을 고정된 우선순위 체인으로 관리합니다. schedule() 함수는 다음 실행할 작업을 찾을 때 이 체인을 따라 stop → dl → rt → fair → idle 순으로 우선순위가 높은 스케줄러부터 검사합니다.

  1. stop_sched_class (정지 스케줄러): 최고 우선순위

    • 핵심 역할: CPU에 가장 긴급하고 독점적인 작업을 처리합니다. 이 작업들은 실시간 프로세스조차도 선점할 수 있으며, CPU를 완전히 독점해야 하는 상황에서 사용됩니다.
    • 주요 사용 사례: CPU 핫플러그 (CPU 비활성화), 프로세서 간 인터럽트(IPI) 처리, 스케줄러 디버깅 등 커널의 핵심 운영에 필수적인 태스크들입니다. 각 CPU마다 최대 하나의 stop 클래스 작업만 존재하며, 해당 CPU에 고정(CPU 바인딩)됩니다.
  2. dl_sched_class (데드라인 스케줄러): 두 번째 우선순위

    • 핵심 역할: 엄격한 마감 시간(deadline) 요구사항이 있는 하드 실시간(Hard Real-Time) 작업을 처리합니다. EDF(Earliest Deadline First) 알고리즘을 사용하여 작업이 지정된 시간 내에 완료되도록 보장합니다.
    • 주요 사용 사례: 산업 제어 시스템, 로봇 공학, 자율 주행 등 밀리초 단위의 정확한 응답이 요구되는 시나리오(예: 센서 데이터 처리, 액추에이터 제어)에 적합합니다. `CONFIG_SCHED_DEADLINE` 커널 컴파일 옵션 활성화 시 사용할 수 있습니다.
  3. rt_sched_class (실시간 스케줄러): 세 번째 우선순위

    • 핵심 역할: 예측 가능한 응답 시간을 제공하는 소프트 실시간(Soft Real-Time) 작업을 관리합니다. SCHED_FIFO (선입선출) 및 SCHED_RR (라운드 로빈) 정책을 사용하며, 일반 프로세스보다 높은 고정 우선순위(0-99)를 가집니다.
    • 주요 사용 사례: 오디오/비디오 스트리밍, 고우선순위 서버 태스크 등 약간의 지연은 허용되지만, 다른 일반 작업보다 우선적으로 실행되어야 하는 경우에 활용됩니다.
      • SCHED_FIFO: 고우선순위 FIFO 작업은 자발적으로 CPU를 양보하거나 더 높은 우선순위 작업에 선점될 때까지 계속 실행됩니다.
      • SCHED_RR: 동일 우선순위의 RR 작업들은 할당된 시간 퀀텀(time slice) 내에서 번갈아 실행되어, 동일 우선순위 작업 간의 기아 상태를 방지합니다.
  4. fair_sched_class (공정 스케줄러): 네 번째 우선순위

    • 핵심 역할: 대부분의 일반 비실시간 작업을 처리합니다. SCHED_NORMAL, SCHED_OTHER, SCHED_IDLE, SCHED_BATCH 등의 정책을 사용하며, "가상 실행 시간(vruntime)" 개념을 통해 모든 실행 가능한 프로세스에 CPU 시간을 공정하게 분배합니다. stop, dl, rt 클래스보다 낮은 우선순위를 가집니다.
    • 주요 사용 사례: 웹 서버, 데이터베이스, 데스크톱 애플리케이션, 백그라운드 배치 작업 등 일상적인 거의 모든 사용자 프로세스 및 백그라운드 프로세스가 이 스케줄러에 의해 관리됩니다. 밀리초 단위의 응답을 요구하지는 않지만, 여러 프로세스가 CPU를 공정하게 공유하고 특정 프로세스가 자원을 독점하여 다른 프로세스가 기아 상태에 빠지는 것을 방지하는 데 중점을 둡니다.
  5. idle_sched_class (유휴 스케줄러): 최저 우선순위

    • 핵심 역할: CPU 유휴 스레드(swapper 스레드)를 처리하는 스케줄러의 "최후의 보루"입니다. stop, dl, rt, fair 클래스에서 실행할 작업이 전혀 없을 때만 활성화됩니다.
    • 주요 사용 사례: 시스템에 실행할 프로세스가 하나도 없을 때 CPU를 저전력 상태로 전환하여 에너지 소비를 줄입니다. 동시에, 어떤 프로세스라도 실행 가능 상태가 되면 즉시 CPU를 양보하도록 보장합니다.

커널 모듈을 통한 프로세스 스케줄러 유형 확인

앞서 설명된 sched_class 인스턴스들은 대부분 커널 내부에서만 사용되며, 외부 커널 모듈이 직접 extern으로 선언하여 접근하기는 어렵습니다. 하지만 task_struct 구조체의 policy 필드는 프로세스의 스케줄링 정책을 직접적으로 나타내므로, 이 필드를 통해 간접적으로 각 프로세스의 스케줄러 유형을 파악할 수 있습니다.

policy 필드의 의미

policy 필드는 프로세스의 스케줄링 정책을 직접적으로 식별하는 데 사용되며, 커널은 이를 통해 다음과 같은 결정을 내립니다.

  • 프로세스가 일반, 실시간 또는 유휴 프로세스인지 구분합니다.
  • 프로세스가 어떤 스케줄러 클래스(fair/rt/dl)에 속하는지 결정합니다.
  • 실시간 스케줄러(RT)의 경우, 구체적인 스케줄링 로직(FIFO/RR)을 식별하는 데 사용됩니다.

linux/sched.h 헤더 파일에 정의된 SCHED_DEADLINE, SCHED_FIFO, SCHED_RR 등의 매크로 값과 policy 필드를 비교하여 프로세스의 스케줄러 유형을 추정할 수 있습니다.

커널 모듈 코드 예시

다음은 시스템 내 활성 프로세스들의 스케줄러 유형을 식별하여 커널 로그에 출력하는 간단한 리눅스 커널 모듈 코드입니다.

// kernel_scheduler_info.c
#include <linux/init.h>
#include <linux/module.h>
#include <linux/sched.h>     // task_struct, SCHED_* 정의 포함
#include <linux/pid.h>       // task_pid_nr 함수용
#include <linux/rculist.h>   // rcu_read_lock/unlock 함수용
#include <linux/sched/signal.h> // for_each_process 매크로용

// 프로세스의 스케줄러 유형을 문자열로 반환하는 헬퍼 함수
static const char *identify_scheduler_type(struct task_struct *proc_task) {
    // 1. IDLE 스케줄러: PID 0 (swapper/idle) 또는 comm에 "swapper" 포함
    if (task_pid_nr(proc_task) == 0 || strstr(proc_task->comm, "swapper") != NULL) {
        return "IDLE (시스템 유휴)";
    }
    // 2. STOP 스케줄러: migration 스레드 (CPU 핫플러그, IPI 등 긴급 커널 작업)
    //    comm에 "migration" 포함하는 경우를 STOP으로 추정
    if (strstr(proc_task->comm, "migration") != NULL) {
        return "STOP (커널 긴급)";
    }
    // 3. DEADLINE 스케줄러: SCHED_DEADLINE 정책 사용
    if (proc_task->policy == SCHED_DEADLINE) {
        return "DEADLINE (하드 실시간)";
    }
    // 4. REAL-TIME 스케줄러: SCHED_FIFO 또는 SCHED_RR 정책 사용
    if (proc_task->policy == SCHED_FIFO || proc_task->policy == SCHED_RR) {
        return "REAL-TIME (소프트 실시간)";
    }
    // 5. FAIR 스케줄러: 나머지 경우 (대부분의 일반 사용자 및 커널 프로세스)
    return "CFS_FAIR (일반 공정)";
}

// 시스템 내 활성 프로세스들의 스케줄러 정보를 출력하는 함수
static void display_active_process_schedulers(void) {
    struct task_struct *current_process;
    int displayed_count = 0;
    const int MAX_PROCESSES_TO_DISPLAY = 20; // 출력할 최대 프로세스 수 제한

    printk(KERN_INFO "--- 시스템 프로세스 스케줄러 정보 (상위 %d개) ---\n", MAX_PROCESSES_TO_DISPLAY);
    rcu_read_lock(); // RCU 락으로 task_struct 리스트 보호

    // for_each_process 매크로를 사용하여 모든 프로세스를 순회
    for_each_process(current_process) {
        if (displayed_count >= MAX_PROCESSES_TO_DISPLAY) {
            break; // 지정된 수만큼 출력 후 순회 중단
        }
        printk(KERN_INFO "[PID %d] 프로세스: %s -> 스케줄러: %s\n",
               task_pid_nr(current_process), current_process->comm,
               identify_scheduler_type(current_process));
        displayed_count++;
    }

    rcu_read_unlock();
    printk(KERN_INFO "--- 정보 출력 완료 ---\n");
}

// 모듈 초기화 함수
static int __init scheduler_classifier_init(void) {
    printk(KERN_INFO "scheduler_classifier 모듈 로드 시작.\n");
    display_active_process_schedulers(); // 시스템 프로세스 정보 출력
    return 0;
}

// 모듈 종료 함수
static void __exit scheduler_classifier_exit(void) {
    printk(KERN_INFO "scheduler_classifier 모듈 언로드 완료.\n");
}

module_init(scheduler_classifier_init);
module_exit(scheduler_classifier_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Kernel Enthusiast");
MODULE_DESCRIPTION("리눅스 프로세스의 스케줄러 유형을 식별하는 간단한 커널 모듈");

모듈 실행 결과 예시

위 커널 모듈을 로드한 후, dmesg 명령어를 통해 출력된 커널 로그는 다음과 유사할 것입니다.

[40696.540310] --- 시스템 프로세스 스케줄러 정보 (상위 20개) ---
[40696.540311] [PID 0] 프로세스: swapper/0 -> 스케줄러: IDLE (시스템 유휴)
[40696.540313] [PID 1] 프로세스: systemd -> 스케줄러: CFS_FAIR (일반 공정)
[40696.540314] [PID 2] 프로세스: kthreadd -> 스케줄러: CFS_FAIR (일반 공정)
[40696.540346] [PID 3] 프로세스: rcu_gp -> 스케줄러: CFS_FAIR (일반 공정)
[40696.540348] [PID 4] 프로세스: rcu_par_gp -> 스케줄러: CFS_FAIR (일반 공정)
[40696.540349] [PID 5] 프로세스: slub_flushwq -> 스케줄러: CFS_FAIR (일반 공정)
[40696.540350] [PID 6] 프로세스: netns -> 스케줄러: CFS_FAIR (일반 공정)
[40696.540351] [PID 7] 프로세스: ksoftirqd/0 -> 스케줄러: CFS_FAIR (일반 공정)
[40696.540353] [PID 8] 프로세스: kworker/0:0H -> 스케줄러: CFS_FAIR (일반 공정)
[40696.540354] [PID 9] 프로세스: rcu_tasks_rude_ -> 스케줄러: CFS_FAIR (일반 공정)
[40696.540356] [PID 10] 프로세스: mm_percpu_wq -> 스케줄러: CFS_FAIR (일반 공정)
[40696.540357] [PID 11] 프로세스: rcu_tasks_trace -> 스케줄러: CFS_FAIR (일반 공정)
[40696.540358] [PID 12] 프로세스: rcu_sched -> 스케줄러: CFS_FAIR (일반 공정)
[40696.540360] [PID 13] 프로세스: migration/0 -> 스케줄러: STOP (커널 긴급)
[40696.540361] [PID 14] 프로세스: idle_inject/0 -> 스케줄러: REAL-TIME (소프트 실시간)
[40696.540362] [PID 15] 프로세스: cpuhp/0 -> 스케줄러: CFS_FAIR (일반 공정)
[40696.540363] [PID 16] 프로세스: cpuhp/1 -> 스케줄러: CFS_FAIR (일반 공정)
[40696.540365] [PID 17] 프로세스: idle_inject/1 -> 스케줄러: REAL-TIME (소프트 실시간)
[40696.540366] [PID 18] 프로세스: migration/1 -> 스케줄러: STOP (커널 긴급)
[40696.540367] [PID 19] 프로세스: ksoftirqd/1 -> 스케줄러: CFS_FAIR (일반 공정)
[40696.540368] --- 정보 출력 완료 ---

태그: Linux kernel Process Scheduling sched_class CPU Scheduler Real-Time Scheduling

11월 12일 09:38에 게시됨