72. 타이머 인터럽트 - 선점형 스케줄링의 기반

핵심 인사이트 (3줄 요약)

본질: 타이머 인터럽트 (Timer Interrupt)는 하드웨어 타이머가 주기적으로 CPU에 보내는 하드웨어 신호로, 운영체제 커널이 제어권을 확보하여 시스템 상태를 갱신하고 멀티태스킹을 수행하게 하는 '시스템의 심장 박동'이다.

가치: 특정 프로세스의 CPU 독점 (Starvation)을 방지하고 선점형 스케줄링 (Preemptive Scheduling)을 가능케 함으로써, 시스템의 공정성과 실시간 응답성을 유지하는 근본적인 메커니즘을 제공한다.

융합: 인터럽트 핸들러, 스케줄러, 타임키핑 시스템과 밀접하게 연계되어 있으며, 현대 운영체제는 전력 소모를 줄이기 위해 동적으로 주기를 조절하는 기술을 채택하고 있다.

Ⅰ. 개요 및 필요성 (Context & Necessity)

개념: 타이머 인터럽트 (Timer Interrupt)는 컴퓨터 내부의 타이머 하드웨어 (PIT, HPET, APIC 등)가 설정된 시간 간격이 지날 때마다 CPU에 강제로 발생시키는 인터럽트 신호다. 이 신호가 발생하면 CPU는 현재 실행 중인 사용자 프로그램의 흐름을 일시 중단하고, 커널 내부에 정의된 타이머 인터럽트 서비스 루틴 (ISR, Interrupt Service Routine)으로 진입한다.
필요성: 만약 타이머 인터럽트가 없다면, 한 번 실행을 시작한 프로그램이 스스로 CPU를 반납 (Yield)하지 않는 한 운영체제는 그 프로그램으로부터 제어권을 뺏어올 방법이 없다. 즉, 무한 루프에 빠진 프로그램 하나가 전체 시스템을 멈추게 할 수 있다. 타이머 인터럽트는 운영체제가 '강제력'을 가지고 자원을 관리할 수 있게 해주는 법적 집행관과 같은 역할을 수행한다.
💡 비유: 타이머 인터럽트는 농구 경기에서 공격 시간을 제한하는 "24초 룰"과 같다. 선수(프로세스)가 아무리 공(CPU)을 오래 가지고 있고 싶어도, 24초가 지나면 벨(인터럽트)이 울리고 공을 상대방에게 넘겨주거나 다시 작전을 짜야 하는 규칙을 강제한다.
등장 배경:
1. 선점형 멀티태스킹 (Preemptive Multitasking): 협력적 멀티태스킹의 한계를 극복하고, 시스템이 주도적으로 프로세스를 교체하기 위한 트리거가 필요해졌다.
2. 시간 기반 자원 할당: 각 프로세스에게 '타임 슬라이스 (Time Slice)'라는 개념을 부여하고 이를 정확히 계측하여 회수할 수단이 요구되었다.
3. 시스템 가용성 보장: 응용 프로그램의 오동작이나 고착 상태(Hang) 시에도 커널이 항상 깨어나 시스템을 복구할 기회를 가져야 했다.

타이머 인터럽트가 발생하여 커널이 실행되고 다시 사용자 모드로 돌아가는 흐름을 시각화하면 다음과 같다. 하드웨어 신호가 소프트웨어의 흐름을 어떻게 제어하는지가 핵심이다.

┌──────────────────────────────────────────────────────────────────────────────────┐
│                      타이머 인터럽트 기반 제어권 전환 흐름                       │
├──────────────────────────────────────────────────────────────────────────────────┤
│                                                                                  │
│   [사용자 모드 (User Mode)]         [커널 모드 (Kernel Mode)]                    │
│                                                                                  │
│   ┌──────────────────┐           ┌────────────────────────────────┐              │
│   │   Process A 실행  │           │  타이머 인터럽트 서비스 루틴(ISR) │          │
│   └────────┬─────────┘           └───────────────┬────────────────┘              │
│            │                                     │                               │
│     (1) 타이머 틱 발생 ────────▶ (2) 현재 CPU 상태 저장 (Context Save)           │
│         (IRQ 0/APIC)                             │                               │
│                                           (3) jiffies 증가 및 시간 갱신          │
│                                                  │                               │
│                                           (4) 타임 슬라이스 소진 확인            │
│                                                  │                               │
│                                           (5) 스케줄러 호출 (need_resched)       │
│                                                  │                               │
│     (7) Process B 실행 ◀──────── (6) 새로운 상태 복원 (Context Restore)          │
│                                                                                  │
└──────────────────────────────────────────────────────────────────────────────────┘

[다이어그램 해설] 위 도식은 타이머 인터럽트가 시스템의 멀티태스킹을 어떻게 주도하는지 보여준다. (1) 하드웨어 타이머가 신호를 보내면 CPU는 즉시 커널 모드로 전환된다. (2) 이때 실행 중이던 Process A의 레지스터 값 등 모든 정보는 커널 스택에 안전하게 보관된다. (3) 커널은 시스템 시간(jiffies)을 1 증가시키고, (4) Process A가 할당받은 시간(예: 10ms)을 모두 썼는지 검사한다. 만약 시간을 다 썼다면 (5) 스케줄러를 호출하여 다음에 실행할 Process B를 결정한다. 마지막으로 (6) Process B의 이전에 저장되었던 상태를 CPU 레지스터에 복원하고 (7) 사용자 모드로 돌아가 Process B를 실행한다. 이 과정은 매우 빈번하게 일어나며, 사용자는 여러 프로그램이 동시에 실행되는 것과 같은 환상(Illusion)을 느끼게 된다.

📢 섹션 요약 비유: 정해진 시간마다 울리는 알람 소리에 맞춰, 현재 작업하던 장부를 덮어 서랍에 넣고 다음 사람이 와서 자기 장부를 꺼내 작업을 시작하는 질서 정연한 교대 근무와 같습니다.

Ⅱ. 아키텍처 및 핵심 원리 (Deep Dive)

구성 요소

요소명	역할	내부 동작	관련 기술	비유
Timer Hardware	주기적 신호 발생	설정된 카운트가 0이 될 때마다 전기적 펄스 송출	Local APIC, PIT	하드웨어 심박 조율기
IDT (Interrupt Descriptor Table)	인터럽트 벡터 매핑	발생한 인터럽트 번호에 대응하는 처리 함수 주소 보관	벡터 0x20 (x86)	119 긴급 연락망
ISR (Interrupt Service Routine)	인터럽트 실제 처리	레지스터 저장, 시간 갱신, 스케줄링 플래그 설정 수행	`timer_interrupt()`	응급 처치 요원
Jiffies / Tick	시스템 시간 단위 카운터	타이머 인터럽트가 발생할 때마다 1씩 증가하는 전역 변수	HZ (Frequency)	출석부 체크 표시
Scheduler (Pick Next)	다음 실행 프로세스 선정	준비 큐(Ready Queue)에서 우선순위에 따라 프로세스 선택	CFS (Completely Fair Scheduler)	다음 타자 결정자

인터럽트 핸들링의 분할 처리 (Top Half & Bottom Half)

타이머 인터럽트 처리는 시스템의 반응성을 유지하기 위해 두 단계로 나뉜다. 인터럽트를 금지하고 빠르게 처리해야 하는 'Top Half'와, 시간이 다소 걸려도 되며 인터럽트를 허용한 상태에서 처리하는 'Bottom Half' (Softirq, Tasklets) 구조다.

┌──────────────────────────────────────────────────────────────────────────────────┐
│                    타이머 인터럽트의 분할 처리 (Split Handling)                  │
├──────────────────────────────────────────────────────────────────────────────────┤
│                                                                                  │
│   [인터럽트 발생]                                                                │
│         │                                                                        │
│   ┌─────▼────────────────────────────────┐                                       │
│   │  Top Half (Hard IRQ)                 │                                       │
│   │  - 인터럽트 비활성화 (전략적)           │ ◀── 최소한의 필수 작업             │
│   │  - jiffies 갱신, HW ACK              │                                       │
│   │  - Softirq 스케줄링                  │                                       │
│   └─────┬────────────────────────────────┘                                       │
│         │                                                                        │
│   ┌─────▼────────────────────────────────┐                                       │
│   │  Bottom Half (Softirq / Tasklets)    │                                       │
│   │  - 인터럽트 활성화                   │ ◀── 무거운 작업 위임                  │
│   │  - 소프트웨어 타이머 만료 확인       │                                       │
│   │  - 스케줄링 로직 실행                │                                       │
│   └──────────────────────────────────────┘                                       │
│                                                                                  │
└──────────────────────────────────────────────────────────────────────────────────┘

[다이어그램 해설] 타이머 인터럽트가 발생했을 때 수행해야 할 일 중에는 '절대 놓쳐서는 안 되는 일'과 '조금 늦어도 되는 일'이 섞여 있다. 하드웨어 신호를 수신했다는 응답(ACK)을 보내고 시스템 클럭을 갱신하는 일은 1마이크로초라도 지체되면 전체 시간의 정확도가 깨지므로 Top Half에서 즉시 처리한다. 반면, 등록된 수천 개의 소프트웨어 타이머 리스트를 뒤져 만료된 것을 찾아 실행하거나 복잡한 스케줄링 계산을 하는 일은 시간이 오래 걸리므로 Bottom Half (리눅스에서는 TIMER_SOFTIRQ)로 넘겨준다. 이렇게 처리 과정을 분리함으로써, 시스템은 타이머 인터럽트를 처리하는 중에도 다른 중요한 하드웨어 인터럽트(네트워크 패킷 도착 등)를 놓치지 않고 수용할 수 있는 높은 응답성을 확보하게 된다.

타임 슬라이스 (Time Slice)와 선점 메커니즘

프로세스가 CPU를 사용할 수 있는 최대 시간인 타임 슬라이스가 타이머 인터럽트에 의해 어떻게 관리되고 회수되는지를 보여주는 타이밍 그래프다.

┌───────────────────────────────────────────────────────────────────────────────────┐
│                      타임 슬라이스 소진 및 프로세스 선점 과정                     │
├───────────────────────────────────────────────────────────────────────────────────┤
│                                                                                   │
│   타이머 틱:   ↓      ↓      ↓      ↓      ↓      ↓      ↓                        │
│   (10ms 주기)  └──────┴──────┴──────┴──────┴──────┴──────┴───                     │
│                                                                                   │
│   프로세스 A:  [=======] [=======] [=======] [===X (Preempted)                    │
│   잔여 시간:    30ms     20ms     10ms      0ms                                   │
│                                                                                   │
│   커널 판정:    PASS     PASS     PASS     STOP & RESCHED                         │
│                                                                                   │
│   컨텍스트 스위치:                            [ Save A / Load B ]                 │
│                                                                                   │
│   프로세스 B:                                            [=======]                │
│                                                                                   │
└───────────────────────────────────────────────────────────────────────────────────┘

[다이어그램 해설] 프로세스 A가 40ms의 타임 슬라이스를 할당받고 실행을 시작했다고 가정하자. 타이머 인터럽트가 10ms마다 발생할 때마다 커널은 A의 잔여 시간을 확인한다. 첫 번째, 두 번째, 세 번째 틱에서는 아직 시간이 남아있으므로 PASS 판정을 내리고 A에게 다시 CPU를 돌려준다. 하지만 네 번째 틱에서 잔여 시간이 0이 되는 순간, 커널은 need_resched 플래그를 설정하고 스케줄러를 호출한다. 이때 프로세스 A는 자신의 의사와 상관없이 CPU를 빼앗기게(Preempted) 되며, 준비 큐에서 기다리던 프로세스 B가 새롭게 CPU를 할당받아 실행된다. 이 메커니즘은 모든 프로세스가 최소한 한 번씩은 CPU를 사용할 수 있도록 보장하는 '민주적인 자원 분배'의 핵심이며, 특정 앱이 멈췄을 때 마우스 커서라도 움직일 수 있는 이유가 바로 이 10ms마다의 강제적인 제어권 회수 덕분이다.

📢 섹션 요약 비유: 놀이터에서 그네(CPU)를 타는 아이에게 선생님(타이머 인터럽트)이 정해진 시간마다 호각을 불어 다음 아이와 교대하게 함으로써, 모든 아이가 공평하게 놀 수 있도록 관리하는 것과 같습니다.

Ⅲ. 융합 비교 및 다각도 분석

비교 1: 고정 주기 타이머 vs 틱리스 (Tickless)

비교 항목	고정 주기 타이머 (Periodic)	틱리스 (Tickless / Dynamic)
동작 방식	할 일이 없어도 정해진 주기마다 발생	다음 이벤트가 예정된 시점에 맞춰 발생
전력 소모	높음 (CPU가 유휴 상태에서도 계속 깨어남)	낮음 (불필요한 인터럽트 제거로 Deep Sleep 가능)
정밀도	틱 주기(HZ)에 의존적	나노초 단위의 정밀한 타이밍 가능
적합한 환경	초기 임베디드, 단순한 서버	모바일 장치, 가상화 환경, 최신 서버
비유	매시간 정각마다 울리는 시계	다음 약속 시간에 맞춰 맞춰둔 알람

비교 2: 하드웨어 인터럽트 vs 소프트웨어 인터럽트 (타이머 관점)

비교 항목	하드웨어 타이머 인터럽트	소프트웨어 타이머 인터럽트
발생 원인	물리적인 클럭 회로의 전기 신호	커널 내부 로직에 의해 예약된 지연 실행
우선순위	매우 높음 (다른 코드 실행 즉시 중단)	낮음 (다른 하드웨어 인터럽트 처리 후 수행)
처리 내용	시스템 시간 갱신, 틱 카운트 증가	유저 타이머 콜백 실행, 네트워크 재전송 처리
비유	불이 났을 때 울리는 비상벨	"30분 뒤에 약 먹기"라고 메모해둔 포스트잇

📢 섹션 요약 비유: 하드웨어 인터럽트가 심장의 근육을 수축시키는 "전기 자극"이라면, 소프트웨어 인터럽트는 그 박동에 맞춰 몸 구석구석으로 피를 보내는 "순환 작용"과 같습니다.

Ⅳ. 실무 적용 및 기술사적 판단

실무 시나리오

시나리오 — 실시간 제어 시스템의 지터 (Jitter) 최적화: 공장 자동화 로봇을 제어하는 실시간 OS (RTOS)에서 타이머 인터럽트 처리 시간이 일정하지 않아 로봇 팔의 움직임에 미세한 떨림이 발생하는 상황. 아키텍트는 타이머 인터럽트의 우선순위를 최상위로 올리고, ISR 내의 불필요한 로직을 Bottom Half로 철저히 격리하여 인터럽트 지연 시간 (Latency)의 변동성(Jitter)을 최소화한다.
시나리오 — 클라우드 환경의 타이머 가상화 오버헤드: 수백 개의 가상 머신(VM)이 돌아가는 하이퍼바이저에서 각 VM이 발생하는 주기적인 타이머 틱이 물리 CPU를 너무 자주 깨워 전체 호스트 성능이 저하되는 상황. 해결책으로 게스트 OS의 NOHZ (Tickless) 옵션을 활성화하여 유휴 상태의 VM이 물리 인터럽트를 발생시키지 않도록 설정한다.
시나리오 — 네트워크 성능 향상을 위한 HZ 값 조정: 리눅스 커널 컴파일 시 CONFIG_HZ 값을 100에서 1000으로 올렸더니 시스템의 응답성은 좋아졌으나, 문맥 교환 오버헤드로 인해 대용량 파일 전송 처리량 (Throughput)이 하락하는 트레이드오프 상황. 실무적으로는 인터랙티브 앱이 많은 데스크톱은 1000Hz를, 대량 데이터 처리가 중요한 서버는 100Hz나 250Hz를 선택하여 균형을 맞춘다.

도입 체크리스트

HZ 설정값: 시스템의 주 목적이 응답성(1000Hz)인가, 처리량(100Hz)인가?
인터럽트 지연 (Latency): 타이머 ISR이 다른 중요한 인터럽트의 처리를 방해하고 있지는 않은가?
전력 관리: 모바일 환경에서 틱리스 커널 옵션이 올바르게 동작하여 배터리 수명을 보호하고 있는가?

안티패턴

ISR 내 복잡한 연산: 타이머 핸들러 내에서 디스크 I/O를 기다리거나 복잡한 부동 소수점 연산을 수행하면 시스템 전체가 얼어버리는(Freeze) 현상이 발생한다. 모든 무거운 작업은 반드시 workqueue나 tasklet으로 넘겨야 한다.
인터럽트 비활성화 방치: 특정 임계 구역을 보호하기 위해 cli() (Disable Interrupts)를 호출한 후 너무 오래 방치하면, 타이머 틱이 유실되어 시스템 시간이 느려지거나 스케줄링이 멈추는 치명적인 버그가 발생한다.
📢 섹션 요약 비유: 응급실 의사(ISR)가 한 환자의 간단한 처치만 하고 다음 환자를 봐야 하는데, 혼자서 대수술(복잡한 연산)을 시작해버리면 대기실의 다른 환자(전체 시스템)들이 위험해지는 것과 같습니다.

Ⅴ. 기대효과 및 결론

정량/정성 기대효과

구분	도입 전 (협력적 모델)	도입 후 (타이머 인터럽트 선점)	개선 효과
공정성	특정 앱이 CPU 독점 가능	모든 앱에 공평한 기회 제공	기아 현상 (Starvation) 원천 차단
안정성	무한 루프 시 시스템 정지	강제 제어권 회수로 복구 가능	시스템 가용성 (Availability) 향상
반응성	사용자 입력 처리가 지연됨	1ms~10ms 단위로 강제 전환	UI 부드러움 및 사용자 경험 최적화

미래 전망

Hardware-Software Co-design: 미래의 CPU는 소프트웨어 개입 없이 하드웨어 수준에서 직접 타임 슬라이스를 관리하고 문맥을 교환하는 기능을 강화하여 인터럽트 오버헤드를 0에 가깝게 줄일 것이다.
AI 기반 동적 틱 조절: 시스템의 부하 패턴을 AI가 학습하여, 인터럽트 주기를 실시간으로 예측하고 조절함으로써 성능과 전력 효율의 극단적인 균형을 맞추는 기술이 등장할 것이다.
📢 섹션 요약 비유: 타이머 인터럽트는 컴퓨터라는 거대한 기계가 멈추지 않고 영원히 박동하게 만드는 "디지털 생명의 에너지원"이며, 현대 컴퓨팅 문명을 가능케 한 가장 단순하면서도 위대한 규칙입니다.

📌 관련 개념 맵 (Knowledge Graph)

개념 명칭	관계 및 시너지 설명
Context Switch	타이머 인터럽트에 의해 유도되는 프로세스 간 상태 전환 작업
Preemptive Scheduling	타이머 인터럽트를 기반으로 운영체제가 실행 주도권을 갖는 방식
Jiffies	타이머 인터럽트 발생 횟수를 저장하는 시스템 시간의 기본 단위
Interrupt Latency	인터럽트 발생 시점부터 실제 처리가 시작될 때까지의 지연 시간
IDT (Interrupt Descriptor Table)	타이머 인터럽트 신호를 처리 함수에 연결해주는 벡터 테이블

👶 어린이를 위한 3줄 비유 설명

타이머 인터럽트는 컴퓨터가 1초에 수백 번씩 스스로를 깨우는 **'마법의 알람'**이에요.
이 알람이 울릴 때마다 컴퓨터는 "지금 하는 일을 잠깐 멈추고, 다음 친구에게 자리를 비워줄까?" 하고 생각해요.
덕분에 우리가 유튜브를 보면서 숙제를 하고 게임을 해도, 컴퓨터가 멈추지 않고 여러 가지 일을 동시에 척척 해낼 수 있는 거랍니다!