2편에서 스케줄러가 준비 큐에서 다음 스레드를 고르는 방법을 봤습니다. 그런데 고른 다음에는 실제로 CPU 위의 스레드를 바꿔 끼우는 작업이 필요합니다. 이것을 컨텍스트 스위칭(context switch, 문맥 교환)이라고 합니다. 2편의 시뮬레이터는 이 비용을 0으로 계산했지만, 실제로는 공짜가 아닙니다.
이 글에서는 스위칭 때 무엇을 저장하는지, 언제 일어나는지 정리한 뒤, 직접 만든 C 프로그램으로 스위칭 한 번에 몇 나노초가 드는지 재 봅니다. 같은 CPU에서 바꿀 때와 다른 CPU를 깨울 때 차이가 얼마나 나는지도 확인합니다. 실습은 Ubuntu 24.04(커널 6.18, Firecracker VM), CPU 2개(Intel Xeon 2.1GHz), gcc 13 환경에서 실행했습니다. 숫자는 이 VM 기준이라 실제 서버나 노트북에서는 다르게 나올 수 있고, 비교(비율)를 중심으로 읽어 주세요.
컨텍스트에는 무엇이 들어 있나
스레드가 CPU에서 실행되는 동안 CPU 안에는 그 스레드의 "작업 중인 상태"가 들어 있습니다. 다른 스레드로 바꾸려면 이 상태를 메모리에 저장하고, 다음 스레드의 상태를 꺼내 CPU에 다시 올려야 합니다.
| 저장·복원하는 것 | 내용 | 스레드 전환 | 프로세스 전환 |
|---|---|---|---|
| 범용 레지스터 | 계산 중이던 값 | O | O |
| 프로그램 카운터(PC) | 다음에 실행할 명령 위치 | O | O |
| 스택 포인터 | 스레드마다 다른 스택의 꼭대기 | O | O |
| 부동소수점·SIMD 레지스터 | 실수·벡터 계산 값 | O | O |
| 주소 공간(페이지 테이블) | 가상 주소 → 물리 주소 지도 | 같은 프로세스면 그대로 | 바꿈 |
1편에서 본 것처럼 같은 프로세스의 스레드들은 주소 공간을 함께 쓰기 때문에, 스레드끼리 바꿀 때는 페이지 테이블을 바꿀 필요가 없습니다. 프로세스가 바뀌면 페이지 테이블도 바꿔야 하고, 주소 변환 결과를 담아 두는 캐시인 TLB도 영향을 받습니다. x86의 PCID 같은 기능이 있으면 TLB 항목에 주소 공간 번호를 붙여 두어 통째로 비우지 않아도 됩니다(이 VM의 CPU도 pcid 플래그가 있습니다).
이 저장·복원 자체(직접 비용)보다 더 클 수 있는 것이 간접 비용입니다. 새로 올라온 스레드가 쓰는 데이터는 CPU 캐시에 없을 가능성이 높아서, 스위칭 직후 한동안 메모리 접근이 느려집니다. 간접 비용은 작업마다 크게 달라서 이 글에서는 재지 않았습니다.
모드 전환과 컨텍스트 스위칭은 다르다
헷갈리기 쉬운 것이 하나 있습니다. read()·write() 같은 시스템 콜을 부르면 CPU가 사용자 모드에서 커널 모드로 넘어갑니다. 이것은 모드 전환이고, 같은 스레드가 커널 코드를 잠깐 실행하는 것일 뿐 다른 스레드로 바뀌는 것이 아닙니다. 시스템 콜이 데이터를 기다려야 해서 스레드를 재우면, 그때 비로소 스케줄러가 다른 스레드로 컨텍스트 스위칭을 합니다. 아래 실험에서 이 두 비용을 나눠서 잽니다.
언제 일어나나: 자발적 vs 비자발적
| 종류 | 언제 | 예 |
|---|---|---|
| 자발적(voluntary) | 스레드가 스스로 CPU를 내놓을 때 | I/O 대기, sleep, 락 대기, 파이프에 읽을 데이터가 없음 |
| 비자발적(nonvoluntary) | 스케줄러가 끌어내릴 때 | 2편의 선점: 몫을 다 썼거나 더 급한 스레드가 깨어남 |
리눅스는 스레드마다 이 횟수를 세어 /proc/<PID>/status에 보여 줍니다. 0.1초씩 80번 잠드는 파이썬 프로그램과, CPU 1번에 함께 붙여 둔 CPU 중심 프로그램 두 개(2편의 spin)를 동시에 돌리고 5초 뒤에 봤습니다.
$ python3 -c "import time
for i in range(80): time.sleep(0.1)" &
$ taskset -c 1 ./spin 8 & taskset -c 1 ./spin 8 &
$ sleep 5; grep ctxt /proc/<PID>/status # 세 프로세스 각각
363 python3 voluntary_ctxt_switches: 50 nonvoluntary_ctxt_switches: 1
364 spin voluntary_ctxt_switches: 0 nonvoluntary_ctxt_switches: 620
365 spin voluntary_ctxt_switches: 1 nonvoluntary_ctxt_switches: 621- 잠들었다 깨기를 반복하는 파이썬은 5초에 자발적 50번(0.1초마다 한 번), 비자발적은 1번뿐입니다.
- CPU 하나를 두고 다투는
spin두 개는 자발적은 0~1번이고 비자발적이 각각 620번입니다. 둘이 합쳐 5초에 약 1,240번, 대략 4ms마다 번갈아 CPU를 넘겨받았습니다.
운영에서 이 값은 좋은 신호가 됩니다. 어떤 프로세스의 비자발적 스위칭이 빠르게 늘고 있다면, 그 프로세스는 CPU를 더 쓰고 싶은데 다른 작업에 밀리고 있다는 뜻입니다(CPU 부족, 컨테이너 CPU 제한, 스레드 과다 등).
실습: 스위칭 한 번은 얼마나 걸릴까
스위칭 비용을 재는 고전적인 방법은 두 실행 흐름이 파이프로 1바이트를 주고받게 하는 것입니다. 부모가 쓰고 → 자식이 읽고 다시 쓰고 → 부모가 읽는 왕복을 하면, 상대가 답을 줄 때까지 각자 잠들어야 하므로 같은 CPU에서는 왕복 한 번에 스위칭이 두 번 일어납니다.
// pingpong.c: 파이프 두 개로 1바이트를 주고받으며 컨텍스트 스위칭 시간을 잰다
// 사용: ./pingpong process|thread [왕복 횟수]
#define _GNU_SOURCE
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
static int p2c[2], c2p[2]; // 부모→자식, 자식→부모
static long N = 200000;
static void *echo(void *arg) { // 받은 바이트를 그대로 돌려준다
char b;
for (long i = 0; i < N; i++) {
if (read(p2c[0], &b, 1) != 1) break;
if (write(c2p[1], &b, 1) != 1) break;
}
return NULL;
}
static double now(void) {
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return ts.tv_sec + ts.tv_nsec / 1e9;
}
int main(int argc, char **argv) {
const char *mode = argc > 1 ? argv[1] : "process";
if (argc > 2) N = atol(argv[2]);
pipe(p2c);
pipe(c2p);
pthread_t th;
pid_t pid = 0;
if (strcmp(mode, "thread") == 0) pthread_create(&th, NULL, echo, NULL);
else if ((pid = fork()) == 0) { echo(NULL); _exit(0); }
char b = 'x';
double t0 = now();
for (long i = 0; i < N; i++) { // 보내고, 답이 올 때까지 잠든다
write(p2c[1], &b, 1);
read(c2p[0], &b, 1);
}
double t1 = now();
if (pid) waitpid(pid, NULL, 0); else pthread_join(th, NULL);
double rt = (t1 - t0) / N * 1e9;
printf("%-7s 왕복 %ld번 %.2f초 왕복 1번 %.0f ns (스위칭 1번 약 %.0f ns 이하)\n",
mode, N, t1 - t0, rt, rt / 2);
return 0;
}process 모드는 fork()로 자식 프로세스를, thread 모드는 같은 프로세스 안에 스레드를 만들어 상대로 씁니다. 다만 이 왕복 시간에는 write·read 시스템 콜 자체의 시간(모드 전환)도 들어 있습니다. 그래서 스위칭 없이 혼자서 파이프에 쓰고 바로 읽는 비용을 따로 재서 빼 줍니다.
// selfpipe.c: 스위칭 없이 같은 프로세스에서 파이프에 쓰고 바로 읽는 비용(시스템 콜 몫)
#include <stdio.h>
#include <time.h>
#include <unistd.h>
int main(void) {
int p[2]; char b = 'x'; long N = 200000;
if (pipe(p)) return 1;
struct timespec a, z;
clock_gettime(CLOCK_MONOTONIC, &a);
for (long i = 0; i < N; i++) { if (write(p[1], &b, 1) != 1 || read(p[0], &b, 1) != 1) return 1; }
clock_gettime(CLOCK_MONOTONIC, &z);
double ns = ((z.tv_sec - a.tv_sec) * 1e9 + (z.tv_nsec - a.tv_nsec)) / N;
printf("write+read 1쌍 %.0f ns (왕복이면 2쌍 = %.0f ns)\n", ns, ns * 2);
}taskset -c 0으로 둘 다 CPU 0번에만 두면 같은 CPU에서 번갈아 실행되고, taskset -c 0,1로 CPU 두 개를 허락하면 스케줄러가 두 흐름을 다른 CPU에 나눠 놓습니다. 세 번씩 돌렸습니다.
$ gcc -O2 -pthread -o pingpong pingpong.c && gcc -O2 -o selfpipe selfpipe.c
$ taskset -c 0 ./selfpipe
write+read 1쌍 398 ns (왕복이면 2쌍 = 796 ns)
write+read 1쌍 383 ns (왕복이면 2쌍 = 765 ns)
write+read 1쌍 373 ns (왕복이면 2쌍 = 746 ns)
$ taskset -c 0 ./pingpong process
process 왕복 200000번 0.57초 왕복 1번 2875 ns (스위칭 1번 약 1437 ns 이하)
process 왕복 200000번 0.52초 왕복 1번 2593 ns (스위칭 1번 약 1297 ns 이하)
process 왕복 200000번 0.51초 왕복 1번 2558 ns (스위칭 1번 약 1279 ns 이하)
$ taskset -c 0 ./pingpong thread
thread 왕복 200000번 0.47초 왕복 1번 2358 ns (스위칭 1번 약 1179 ns 이하)
thread 왕복 200000번 0.47초 왕복 1번 2372 ns (스위칭 1번 약 1186 ns 이하)
thread 왕복 200000번 0.47초 왕복 1번 2356 ns (스위칭 1번 약 1178 ns 이하)
$ taskset -c 0,1 ./pingpong process 100000
process 왕복 100000번 2.40초 왕복 1번 23980 ns (스위칭 1번 약 11990 ns 이하)
process 왕복 100000번 2.34초 왕복 1번 23421 ns (스위칭 1번 약 11711 ns 이하)
process 왕복 100000번 2.32초 왕복 1번 23181 ns (스위칭 1번 약 11590 ns 이하)왕복 시간에서 시스템 콜 몫(약 770ns)을 빼고 2로 나누면 스위칭 한 번의 대략적인 비용이 나옵니다.
| 경우 | 왕복 1번 (중간값) | 시스템 콜 몫 | 스위칭 1번 (추정) |
|---|---|---|---|
| 같은 CPU, 프로세스끼리 | 2,593 ns | 약 770 ns | 약 0.9 µs |
| 같은 CPU, 같은 프로세스의 스레드끼리 | 2,358 ns | 약 770 ns | 약 0.8 µs |
| 다른 CPU, 프로세스끼리 | 23,421 ns | 약 770 ns | 약 11 µs (스위칭이 아니라 '깨우기' 비용, 아래 설명) |
결과에서 읽을 수 있는 것은 세 가지입니다.
- 스위칭 한 번은 1µs 안팎입니다. 이 VM 기준으로 시스템 콜 한 쌍(약 0.38µs)의 2~3배쯤입니다. 1초에 수천 번 스위칭하는 것은 문제가 아니지만, 아래 vmstat처럼 1초에 수십만 번이 되면 CPU 시간의 상당 부분이 스위칭에 쓰입니다.
- 스레드 전환이 프로세스 전환보다 약 10% 빨랐습니다. 주소 공간을 바꾸지 않아도 되기 때문입니다. 다만 차이가 생각보다 작은데, PCID 덕분에 프로세스 전환 때도 TLB를 통째로 비우지 않기 때문으로 보입니다(이 부분은 재지 않은 추정입니다). 캐시가 식는 간접 비용까지 생각하면 실제 차이는 작업에 따라 더 벌어질 수 있습니다.
- CPU를 둘 주니 오히려 10배 가까이 느려졌습니다. 이때는 두 흐름이 각자 다른 CPU에 있어서 스위칭이 일어나는 대신, 상대가 잠든 CPU를 깨워야 합니다. 다른 CPU에 깨우라는 신호(IPI)를 보내고, 할 일이 없어 쉬고 있던 CPU가 깨어나 스레드를 올리는 데 시간이 듭니다. 이 환경은 가상 머신이라 쉬는 CPU를 깨우는 비용이 실제 서버보다 클 가능성이 높습니다. "CPU를 많이 줄수록 항상 빠르다"가 아니라는 점은 기억해 둘 만합니다. 서로 자주 주고받는 작업은 같은 CPU에 두는 편이 빠를 수 있습니다.
vmstat로 시스템 전체 스위칭 보기
vmstat 1의 cs 열은 시스템 전체의 초당 컨텍스트 스위칭 횟수입니다. 가만히 있을 때와, 2초째부터 pingpong을 100만 번 돌렸을 때를 비교했습니다.
$ vmstat 1 6
procs -----------memory---------- ---swap-- -----io---- -system-- -------cpu-------
r b swpd free buff cache si so bi bo in cs us sy id wa st gu
1 0 0 7747952 11316 304432 0 0 1492 6 7073 157 14 4 82 0 0 0
0 0 0 7747964 11316 304472 0 0 0 0 95 108 0 0 100 0 0 0
1 0 0 7747964 11316 304472 0 0 0 0 90 118 1 0 99 0 0 0
2 0 0 7747964 11316 304472 0 0 0 0 330 814530 7 43 50 0 1 0
2 0 0 7747964 11316 304472 0 0 0 0 315 814770 9 40 50 0 1 0
0 0 0 7747964 11316 304472 0 0 0 0 239 370954 4 20 76 0 1 0평소 초당 100번대이던 cs가 약 81만 번으로 뛰고, 커널 모드 CPU 시간(sy)이 40% 넘게 올라갑니다(CPU 0번 하나만 쓰므로 전체의 50%가 최대). 사용자 코드(us)는 7~9%뿐입니다. 이 프로그램은 쓸모 있는 일 없이 1바이트를 주고받기만 하니 극단적인 예지만, 운영 서버에서 cs가 평소보다 크게 높고 sy 비율이 높다면 스레드가 너무 많거나, 락을 두고 잦은 대기·깨우기가 일어나고 있을 가능성을 의심해 볼 수 있습니다. 프로세스별로 좁혀 보려면 위의 /proc/<PID>/status 값을 시간 간격을 두고 두 번 읽어 차이를 봅니다.
스위칭을 줄이는 설계
| 상황 | 스위칭이 늘어나는 이유 | 줄이는 방법 |
|---|---|---|
| 요청마다 스레드 하나 (thread-per-request) | 동시 접속 수만큼 스레드가 생기고 서로 번갈아 실행 | 스레드 풀 크기 제한, 이벤트 루프·비동기 I/O |
| CPU 코어보다 훨씬 많은 CPU 중심 스레드 | 서로 밀어내는 비자발적 스위칭 | CPU 중심 작업 스레드 수 ≈ 코어 수 |
| 락을 두고 자주 다툼 | 락을 못 잡은 스레드가 잠들고 깨어남 | 임계 구역을 짧게, 락 쪼개기(4편 동기화에서) |
| 작업을 아주 잘게 쪼개 다른 스레드에 넘김 | 넘길 때마다 깨우기·스위칭 | 일을 묶어서 넘김(배치) |
Node.js가 연결 수천 개를 메인 스레드 하나로 처리할 수 있는 이유도 여기에 있습니다. 연결마다 스레드를 두고 잠재우는 대신, 운영체제의 이벤트 통지(리눅스의 epoll)로 준비된 연결만 골라 한 스레드에서 차례로 처리하니 연결 수가 늘어도 컨텍스트 스위칭이 그만큼 늘지 않습니다. 이 I/O 모델은 시리즈 7편에서 자세히 다룹니다.
실무에서 겪은 일
제 경우 컨텍스트 스위칭과 커널 CPU(sy)가 치솟는 문제는 요청이 몰려 QPS가 올라갈 때 주로 터졌고, 특히 ffmpeg으로 영상을 만드는 작업이 같이 돌 때 그랬습니다. ffmpeg은 인코딩할 때 기본적으로 코어 수에 맞춰 여러 스레드를 띄워 CPU를 최대한 쓰기 때문에, 같은 서버에서 요청을 처리하는 스레드와 CPU를 두고 다투게 됩니다. 위 표의 "CPU 코어보다 훨씬 많은 CPU 중심 스레드" 상황이 그대로 생기는 셈입니다. 비슷한 작업이 있다면 ffmpeg -threads N으로 스레드 수를 제한하거나, 영상 작업을 요청 처리 서버와 다른 곳에서 돌리는 방법부터 검토해 볼 만합니다.
정리
- 컨텍스트 스위칭은 CPU 위의 스레드를 바꾸는 일로, 레지스터·PC·스택 포인터 등을 저장·복원합니다. 프로세스가 바뀌면 주소 공간(페이지 테이블)도 바꿉니다. 시스템 콜로 커널에 들어가는 모드 전환과는 다릅니다.
- 스레드가 스스로 CPU를 내놓으면 자발적, 스케줄러가 끌어내리면 비자발적 스위칭입니다.
/proc/<PID>/status의nonvoluntary_ctxt_switches가 빠르게 늘면 CPU 경쟁을 의심합니다. - 이 VM에서 같은 CPU의 스위칭 한 번은 프로세스 약 0.9µs, 스레드 약 0.8µs였습니다. 다른 CPU를 깨워 주고받으면 왕복이 10배 가까이 느려졌습니다.
vmstat 1의cs와sy로 시스템 전체의 스위칭 부담을 볼 수 있습니다. 스레드 수 제한, 이벤트 루프, 임계 구역 줄이기로 스위칭을 줄입니다.- 다음 글에서는 여러 스레드가 같은 데이터를 동시에 고칠 때 생기는 문제와 해결 도구인 동기화(뮤텍스·세마포어)를 다룹니다.
참고 자료
- proc_pid_status(5) — Linux manual page (voluntary_ctxt_switches)
- vmstat(8) — Linux manual page
- pipe(7) — Linux manual page
- sched(7) — Linux manual page
- taskset(1) — Linux manual page
이 글은 AI 도구로 초안을 만들고 저자가 검토·보완했습니다.