가상 메모리와 페이지 교체 알고리즘

가상 메모리(Virtual Memory)는 실제 RAM보다 큰 주소 공간을 프로세스에게 제공하는 기법이다. 지금 필요한 페이지만 RAM에 올리고 나머지는 디스크에 두며, 자리가 모자라면 어떤 페이지를 내보낼지 정하는 게 페이지 교체 알고리즘이다. 4과목 운영체제에서 페이지 교체 알고리즘의 페이지 부재(Page Fault) 횟수 계산은 거의 매 회차 고정 출제되는 계산형 1순위 빈출이다. 35강 고정/가변 분할(★고내가외★)이 메모리 분할 차원이었다면, 36강 페이징/세그먼테이션은 같은 원리(고정→내부 / 가변→외부)가 분산 할당으로 확장된 단원이다.

핵심 암기: 페이징/세그먼테이션 분별 ★페고내·세가외★(페이징=고정→내부 / 세그먼테이션=가변→외부) · 페이지 교체 6종 ★FLLON OS★(FIFO·LRU·LFU·OPT·NUR·SCR) · Belady 이상 현상 = FIFO 단독 · EAT = (1−p)×메모리 + p×폴트 · 스래싱 방지 = 워킹셋·PFF

PART A — 가상 메모리와 분산 할당

가상 메모리란? ·가상 메모리·

[정의] 가상 메모리(Virtual Memory) = 실제 RAM(물리 메모리)보다 더 큰 주소 공간을 프로세스에게 제공하는 기법. 프로그램 전체를 메모리에 올리지 않고 지금 참조되는 부분만 RAM에 적재하며, 나머지는 디스크의 스왑 공간(Swap Space)에 둔다.

[표] 가상 메모리 핵심

💡 책상(RAM·작고 빠름)에는 책 3~4권만 올라가는데 시험 범위는 20권. 지금 보는 책만 책상에, 나머지는 책장(디스크·크고 느림)에 두는 게 가상 메모리.

🔑 암기 "가상 메모리 = RAM보다 큰 주소 공간 + 필요한 페이지만 RAM에 적재"

⚠️ 함정 "가상 메모리 = RAM 용량을 물리적으로 늘리는 것" ❌(→ 디스크를 빌려 큰 것처럼 보이게 하는 기법) / "전체 프로그램을 한 번에 적재" ❌(→ 필요한 부분만).

🎯 빈출 정의보다 페이징·페이지 부재·교체 알고리즘으로 변형 출제. 매 회차 1~2문항의 전제 개념.

페이징 — 고정 크기 블록 ·가상 메모리·

[정의] 페이징(Paging) = 가상 메모리와 물리 메모리를 동일한 고정 크기 블록으로 잘라 페이지 단위로 적재·교체하는 기법. 가상 메모리를 자른 조각이 페이지, 물리 메모리(RAM)를 자른 조각이 프레임이며 둘은 같은 크기(보통 4KB)다.

[표] 페이징 핵심

[흐름] 페이지 테이블 — 가상 페이지가 어느 프레임에 있는지(Valid 비트로 적재 여부 표시)

페이지 테이블 (프로세스마다 1개)
  페이지 0 → 프레임 5   Valid 1    RAM에 있음
  페이지 1 → 프레임 2   Valid 1    RAM에 있음
  페이지 2 → (디스크)   Valid 0    지금 RAM에 없음 → 참조 시 페이지 부재
  페이지 3 → 프레임 7   Valid 1    RAM에 있음

🔑 암기 "페이지 = 가상 메모리 조각 / 프레임 = RAM 조각 / 둘은 같은 크기 / 페이지 테이블 = 페이지→프레임 매핑"

⚠️ 함정 "페이지 테이블 = 시작주소 + 길이" ❌(→ 그건 세그먼트 테이블·페이지 테이블은 프레임 번호 매핑) / "페이지와 프레임 크기가 다르다" ❌(→ 같다).

🎯 빈출 페이지 vs 프레임 vs 세그먼트 용어 매칭, 테이블 형식 바꿔치기. 매 회차.

세그먼테이션 — 가변 논리 단위 ·가상 메모리·

[정의] 세그먼테이션(Segmentation) = 프로세스를 논리적 단위(세그먼트)로 나누어 적재하는 기법. 코드·데이터·스택·힙처럼 프로그래머가 보는 논리 구조 그대로 나누므로 세그먼트마다 크기가 가변이다.

[흐름] 가변 크기 — 논리 단위마다 다름

[ 코드 8KB ][ 데이터 4KB ][ 스택 2KB ][ 힙 12KB ]
   세그먼트마다 크기 다름 → 할당·해제 반복 시 사이에 자투리 = 외부 단편화

[비교] 페이지 테이블 vs 세그먼트 테이블 — 형식이 다르다

🔑 암기 "세그먼테이션 = 논리 단위·가변 크기·외부 단편화 / 세그먼트 테이블 = 시작주소 + 길이"

⚠️ 함정 "세그먼테이션 = 고정 크기" ❌(→ 가변) / "세그먼트 테이블 = 페이지→프레임 매핑" ❌(→ 시작주소+길이) / "페이징이 공유·보호에 유리" ❌(→ 세그먼테이션이 논리 단위라 유리).

🎯 빈출 페이징과의 분별(다음 카드 ★페고내·세가외★). 매 회차 1순위 함정.

페이징 vs 세그먼테이션 — ★페고내·세가외★ ·가상 메모리·시험 1순위·

[정의] 페이징·세그먼테이션의 단편화 분별을 한 번에 묶는 두음이 ★페고내·세가외★. 35강 ★고내가외★(고정 분할→내부 / 가변 분할→외부)의 확장 — 분산 할당에서도 같은 원리가 그대로 적용된다.

[분류] ★페고내·세가외★

★페고내·세가외★

페 = 페이징(Paging)
고 = 고정 크기 (페이지 = 프레임)
내 = 내부 단편화 (할당 영역 안쪽 빈 공간)

세 = 세그먼테이션(Segmentation)
가 = 가변 크기 (논리 단위)
외 = 외부 단편화 (할당 영역 바깥쪽 자투리)

[표] 종합 분별

💡 미리 정한 고정 크기로 자르면 영역 안쪽에 빈 공간(내부)이 남고, 논리 단위 가변 크기로 자르면 영역 바깥쪽에 자투리(외부)가 흩어진다. 35강 고정/가변 분할과 완전히 같은 원리.

🔑 암기 "★페고내·세가외★ — 페이징=고정→내부 / 세그먼테이션=가변→외부. 35강 ★고내가외★의 분산 할당 확장"

⚠️ 함정 "페이징=외부 / 세그먼테이션=내부" ❌(→ 정반대·가장 흔한 함정) / "페이지 테이블=시작주소+길이" ❌(→ 세그먼트 테이블).

🎯 빈출 페이징/세그먼테이션 ↔ 내부/외부 자리 바꿔치기. 매 회차 1순위.

📝 기출 페이징=내부 / 세그먼테이션=외부 (옳은 것 고르기) · 기출 3

PART B — 요구 페이징과 페이지 부재

요구 페이징 — 필요할 때만 적재 ·페이지 부재·

[정의] 요구 페이징(Demand Paging) = 프로세스 시작 시 모든 페이지를 미리 올리지 않고, 실제로 참조될 때만 해당 페이지를 적재하는 기법. 다른 이름은 Lazy Loading(게으른 적재).

[표] 요구 페이징 핵심

💡 동영상 스트리밍처럼 전체를 다 받지 않고 지금 재생 구간만 메모리에 올리고, 다음 구간이 필요하면 그때 추가로 받는다.

🔑 암기 "요구 페이징 = 필요할 때만 적재(Lazy Loading) · 페이지 부재는 정상 동작의 일부"

⚠️ 함정 "페이지 부재 = 시스템 오류" ❌(→ 요구 페이징의 정상 동작 일부·부재율을 낮추는 게 과제) / "요구 페이징 = 모든 페이지 미리 적재" ❌(→ 그건 Pre-paging).

🎯 빈출 Lazy Loading 매칭, Pre-paging과의 분별. 보통.

페이지 부재 처리 6단계 ·페이지 부재·

[정의] 페이지 부재(Page Fault) = CPU가 참조하려는 페이지가 현재 RAM에 없는 상태. 페이지 테이블의 Valid 비트가 0이면 MMU가 감지해 Page Fault Trap을 발생시키고 OS로 제어권이 넘어간다.

[흐름] 페이지 부재 처리 6단계

[1] CPU가 가상 주소 V 참조
       ↓
[2] MMU가 페이지 테이블 조회 → Valid 비트 0 → Page Fault Trap 발생
       ↓
[3] OS가 제어권 인수 → 디스크에서 해당 페이지 위치 확인
       ↓
[4] 빈 프레임이 있는가?
     있음 → 디스크에서 그 프레임으로 페이지 적재
     없음 → 페이지 교체 알고리즘 실행 → 희생 페이지를 디스크로 내보내고 적재
       ↓
[5] 페이지 테이블 갱신 (페이지→프레임 매핑·Valid 비트 1)
       ↓
[6] 중단된 명령어 재시도 → CPU가 다시 V 참조 → 성공

[표] 비용

🔑 암기 "부재 처리 = Trap → 디스크 위치 확인 → (빈 프레임 없으면 교체) → 적재 → 테이블 갱신 → 재시도"

⚠️ 함정 "Valid 비트 1 = 페이지 부재" ❌(→ Valid 0이 부재) / "부재 시 프로세스 강제 종료" ❌(→ 페이지 적재 후 명령어 재시도).

🎯 빈출 Valid 비트·Trap·재시도 흐름. 보통.

EAT 공식 + 페이지 부재율 ·페이지 부재·시험 1순위·

[정의] EAT(Effective Access Time·실효 접근 시간) = 페이지 부재 비용까지 반영한 평균 메모리 접근 시간. 페이지 부재율 p(부재 횟수 ÷ 참조 횟수)가 단 1%만 돼도 평균 접근이 약 1000배 느려진다.

[흐름] EAT 공식과 계산 예

EAT = (1 - p) × 메모리 접근 시간 + p × 페이지 부재 처리 시간
p = 페이지 부재율 = 부재 횟수 ÷ 참조 횟수

예: 메모리 100ns / 부재 처리 10ms = 10,000,000ns / p = 0.01
EAT = 0.99 × 100 + 0.01 × 10,000,000
    = 99 + 100,000 ≈ 100,099 ns   (부재율 1%에 약 1000배 느려짐)

단위 환산(함정 1순위): 1 ms = 1,000,000 ns

🔑 암기 "EAT = (1−p)×메모리 + p×폴트 · 부재율 p = 부재÷참조 · 1ms = 1,000,000ns"

⚠️ 함정 단위 환산(ms→ns) 누락 ❌(→ 자릿수가 통째로 틀림·매년 1순위) / "부재율 p = 참조÷부재" ❌(→ 부재÷참조).

🎯 빈출 EAT 계산·단위 환산. 매 회차 계산 후보.

📝 기출 EAT 계산(단위 환산) · 기출 4

PART C — 페이지 교체 알고리즘 ★FLLON OS★

페이지 교체 6종 — ★FLLON OS★ ·페이지 교체·시험 1순위·

[정의] 빈 프레임이 없을 때 어떤 페이지를 내보낼지 정하는 게 페이지 교체 알고리즘. 6종을 한 번에 묶는 두음이 ★FLLON OS★. 가운데 OS는 'Operating System 영역'을 환기하는 보조 글자라 외우기 쉽다.

[분류] ★FLLON OS★

★FLLON OS★

F = FIFO  (First In First Out · 먼저 들어온 것 · 큐 · Belady 발생)
L = LRU   (Least Recently Used · 최근에 가장 안 쓴 것 · 시간 기준 · OPT 근접)
L = LFU   (Least Frequently Used · 가장 적게 쓴 것 · 횟수 기준)
O = OPT   (Optimal · 앞으로 가장 오래 안 쓸 것 · 이론적 최소 · 구현 불가)
N = NUR   (Not Used Recently · R/M 비트 · LRU 근사)
[O S]     ← Operating System 영역 환기 (보조 글자)
S = SCR   (Second Chance · FIFO + 2차 기회)

[표] 6종 종합

🔑 암기 "★FLLON OS★ — F=큐 / L=시간 / L=횟수 / O=이론 / N=근사 / S=2차 기회"

⚠️ 함정 "LRU=횟수 / LFU=시간" ❌(→ 정반대·Recently=시간 / Frequently=횟수) / "OPT가 현실에서 가장 많이 사용" ❌(→ 구현 불가).

🎯 빈출 6종 정의 매칭(옳지 않은 것 고르기), 시간/횟수 자리 바꿔치기. 매 회차 1순위.

📝 기출 6종 정의 매칭(LFU '최근' 함정) · 기출 5

시간 vs 횟수 — LRU·LFU·OPT 분별 ·페이지 교체·시험 1순위·

[정의] 시험 1순위 함정이 LRU(시간) ↔ LFU(횟수) 자리 바꿔치기다. LRU는 마지막 참조 시각, LFU는 누적 참조 횟수가 기준이다. OPT는 미래를 알아야 하는 이론적 기준선이다.

[비교] LRU vs LFU

💡 페이지 P가 시작 직후 1000번 쓰인 뒤 안 쓰이면, LRU는 곧 내보내고(오래 안 쓰니까) LFU는 끝까지 남긴다(1000번 vs 신규 1~2번) — 정반대 결정.

[표] OPT — 이론적 기준선

🔑 암기 "LRU=시간(Recently) / LFU=횟수(Frequently) / OPT=미래·이론 최소·구현 불가"

⚠️ 함정 "LFU = 가장 최근에 쓴 페이지 교체" ❌(→ 가장 적게 쓴·횟수) / "OPT에서 Belady 발생" ❌(→ FIFO 단독·OPT는 단조 감소) / "LRU가 OPT보다 부재 적음" ❌(→ OPT가 이론적 최소).

🎯 빈출 '최근' 단어를 LFU 자리에 끼워 LRU와 혼동시키는 매칭. 매 회차 1순위.

💡 보충 현대 OS의 페이지 회수, DBMS 버퍼 풀, 캐시 시스템의 메모리 정책은 대부분 LRU·LFU 계열을 변형해 쓴다 — 순수 LRU는 비용이 커서 근사로 구현(실무 일반론).

NUR·SCR — 비트 기반 2종 ·페이지 교체·

[정의] NUR(Not Used Recently) = 참조 비트 R + 수정 비트 M 2개로 LRU를 근사. SCR(Second Chance Replacement) = FIFO에 R 비트 검사를 더해 한 번 더 기회를 주는 개선판이다.

[흐름] NUR — (R, M) 4클래스 교체 순서

교체 1순위 → 4순위 (절대 순서)

(0, 0) → (0, 1) → (1, 0) → (1, 1)
   ↑                          ↑
 1순위 교체                  4순위 교체
 (최근 안 봤고 수정 X)      (최근 봤고 수정까지)

[흐름] SCR — R=1이면 큐 뒤로(2차 기회), R=0이면 즉시 교체

큐 앞 페이지 R 비트 검사
  R = 1 → R를 0으로 갱신하고 큐 맨 뒤로 (한 번 더 기회)
  R = 0 → 즉시 교체

원형 큐로 구현하면 = Clock Algorithm

🔑 암기 "NUR = (0,0)→(0,1)→(1,0)→(1,1) 절대 순서 · SCR = FIFO + R=1이면 큐 뒤로 / R=0이면 교체"

⚠️ 함정 "NUR (1,1)→(1,0)→(0,1)→(0,0)" ❌(→ (0,0)부터 교체) / "SCR은 R=1이면 즉시 교체" ❌(→ R=0이 즉시 교체·R=1은 2차 기회) / "NUR은 비트 없이 동작" ❌(→ R/M 하드웨어 비트 필요).

🎯 빈출 NUR 4클래스 순서, SCR의 R 비트 동작. 간헐~보통.

페이지 교체 계산 — FIFO·LRU·OPT 손풀이 ·페이지 교체·매 회차 계산·

[정의] 매 회차 고정 출제되는 계산형. 참조열과 프레임 수가 주어지면 프레임 표를 칸 단위로 추적해 페이지 부재 수를 센다. 빈 프레임에 처음 올리는 것도 부재(Cold Miss)로 카운트한다.

[흐름] 손풀이 5단계

[1] 참조열을 가로로 쓰기 (열 헤더)
[2] 프레임 수만큼 세로 행 만들기 (3프레임 → 3행)
[3] 각 참조마다 — 프레임에 있으면 Hit, 없으면 Miss(부재)
      빈 프레임 있으면 → 빈 칸에 적재
      없으면 → 알고리즘 규칙으로 희생 페이지 결정 후 교체
[4] 부재인 칸에 ● 표시
[5] 부재 수 세기 + 부재율 = 부재 ÷ 참조

[표] FIFO 추적 — 참조열 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1 · 3프레임 (큐 앞=가장 오래된 것 희생)

[비교] 같은 참조열·3프레임 — 알고리즘만 바꾸면 부재 수가 달라진다

💡 부등식 OPT ≤ LRU ≤ FIFO — OPT는 항상 다른 모든 알고리즘 이하. LRU는 동일 참조가 Hit돼도 마지막 참조 시각을 갱신하는 게 손풀이 핵심.

🔑 암기 "손풀이 = 참조열 → 프레임 표 → 부재 ● → 부재율(부재÷참조) · Cold Miss도 부재 · OPT ≤ LRU ≤ FIFO"

⚠️ 함정 "빈 프레임에 처음 적재는 부재 아님" ❌(→ Cold Miss도 부재) / "LRU는 Hit이면 아무것도 안 함" ❌(→ Hit도 마지막 참조 시각 갱신).

🎯 빈출 FIFO·LRU 부재 횟수 계산. 매 회차 고정(킬러 1문항).

📝 기출 LRU 부재 횟수 계산 · 기출 1

Belady 이상 현상 — FIFO 단독 ·페이지 교체·시험 1순위·

[정의] Belady 이상 현상(Belady's Anomaly) = 프레임 수를 늘렸는데 페이지 부재 수가 오히려 늘어나는 황당 현상. Laszlo Belady가 1969년 발견했고, FIFO에서만 나타난다. LRU·OPT는 프레임을 늘리면 부재가 절대 늘지 않는다(단조 감소).

[표] 시그니처 참조열 1 2 3 4 1 2 5 1 2 3 4 5 · FIFO 3프레임

[표] 같은 참조열 · FIFO 4프레임

💡 3프레임 = 9회, 4프레임 = 10회. 책상이 커졌는데 책 꺼내는 횟수가 늘어난 셈 — 상식과 정반대인 FIFO만의 현상.

🔑 암기 "Belady = 프레임↑인데 폴트↑ · FIFO 단독 · 1 2 3 4 1 2 5 1 2 3 4 5 → 3F=9·4F=10"

⚠️ 함정 "LRU·OPT에서도 Belady 발생" ❌(→ FIFO 단독·둘은 단조 감소) / "프레임을 늘리면 항상 부재가 준다" ❌(→ FIFO는 예외 가능).

🎯 빈출 'FIFO' + '프레임↑인데 폴트↑' 두 단서로 용어 고르기. 매 회차 1순위.

📝 기출 Belady 이상 현상 용어 고르기 · 기출 2

PART D — 스래싱·지역성·TLB

스래싱 + 워킹셋·PFF ·메모리 관리·

[정의] 스래싱(Thrashing) = 페이지 부재가 너무 자주 일어나 CPU가 실제 일은 못 하고 페이지 교체에만 시간을 허비하는 상태. 다중 프로그래밍 정도(MPD)가 너무 높아 각 프로세스의 워킹셋을 RAM이 못 담을 때 발생한다. 방지 도구가 워킹셋과 PFF다.

[흐름] MPD가 임계점을 넘으면 CPU 이용률 급락

CPU 이용률
  높음 |        ___정상___
       |      _/         \
       |    _/            \___        ← 임계점 넘으면 급락 (스래싱)
  낮음 |__/                   \______
       +----------------------------- 다중 프로그래밍 정도(MPD)

[비교] 스래싱 방지 두 도구 — 발상이 다르다

💡 워킹셋 = '요즘 자주 보는 책은 책상에 계속 둔다'(W(t,Δ) = 시간 창 Δ 동안 참조한 페이지 집합). PFF = '1분당 책 꺼내는 횟수'를 보고 칸을 늘리거나 줄인다.

🔑 암기 "스래싱 = 교체에만 시간 허비·CPU 이용률 ↓·부재율 ↑ / 방지 = 워킹셋(집합·Denning) + PFF(빈도·임계값)"

⚠️ 함정 "스래싱 시 CPU 이용률 증가" ❌(→ 급락) / "MPD가 낮을수록 스래싱" ❌(→ 높을수록·임계점 초과) / "워킹셋 = PFF" ❌(→ 집합 vs 빈도·다른 발상).

🎯 빈출 스래싱 시그니처(MPD↑·CPU↓·부재율↑), 워킹셋/PFF 분별. 매 회차 후보.

📝 기출 스래싱·워킹셋·PFF 분별 · 기출 6

지역성(시간·공간) + TLB ·하드웨어 지원·

[정의] 지역성(Locality) = 프로그램이 메모리를 고르게 쓰지 않고 일부에 몰아 참조하는 성질. 페이지 교체 알고리즘이 잘 동작하는 이론적 근거다. TLB(Translation Lookaside Buffer)는 페이지 테이블의 캐시로, CPU 옆 초고속 메모리에 자주 쓰는 매핑을 둔다.

[표] 시간 지역성 vs 공간 지역성

[표] TLB — 페이지 테이블의 캐시

💡 연락처 1000명이 페이지 테이블(RAM)이라면 단축번호 10개가 TLB. 자주 거는 번호는 단축번호로 즉시(TLB Hit), 가끔 거는 번호는 검색(TLB Miss).

🔑 암기 "시간 지역성=for 반복문 / 공간 지역성=배열 순차 접근 · TLB=페이지 테이블 캐시·CPU 옆·Hit률 90~99%"

⚠️ 함정 "TLB = 페이지 그 자체를 저장" ❌(→ 페이지→프레임 매핑을 저장) / "공간 지역성 = 같은 주소 재참조" ❌(→ 그건 시간·공간은 근처 주소).

🎯 빈출 시간/공간 지역성 분별, TLB 정의. 간헐~보통.

기출 다지기

[기출 1 출제] 참조열 2 3 2 1 5 2 4 5 3 2 5 2, 프레임 수 3, LRU 알고리즘으로 페이지 교체 시 페이지 부재 횟수는? (계산)

• ① 6
• ② 7
• ③ 8
• ④ 9

[기출 2 출제] FIFO에서 발생하며, 프레임 수를 늘렸음에도 페이지 부재가 오히려 늘어나는 현상은? (설명→용어)

• ① 스래싱(Thrashing)
• ② Belady의 모순(Belady's Anomaly)
• ③ PFF(Page Fault Frequency)
• ④ 워킹셋(Working Set)

[기출 3 출제] 페이징과 세그먼테이션의 단편화에 대한 설명으로 옳은 것은? (옳은 것 고르기)

• ① 페이징=내부 / 세그먼테이션=외부
• ② 페이징=외부 / 세그먼테이션=내부
• ③ 둘 다 외부
• ④ 둘 다 내부

[기출 4 출제] 메모리 접근 시간 100 ns, 페이지 부재 처리 시간 10 ms, 페이지 부재율 0.001(0.1%) 일 때 EAT는? (계산)

• ① 약 100 ns
• ② 약 200 ns
• ③ 약 10,099 ns
• ④ 약 100,000 ns

[1] 단위 환산: 10 ms = 10,000,000 ns
[2] EAT = 0.999 × 100 + 0.001 × 10,000,000
        = 99.9 + 10,000 = 10,099.9 ns ≈ 약 10,099 ns

[기출 5 출제] 페이지 교체 알고리즘 설명 중 옳지 않은 것은? (부정형)

• ① FIFO — 큐 자료구조 사용
• ② LRU — 최근에 가장 오래 사용되지 않은 페이지 교체
• ③ LFU — 가장 최근에 사용된 페이지 교체
• ④ OPT — 앞으로 가장 오래 사용되지 않을 페이지 교체·구현 불가

[기출 6 출제] 스래싱(Thrashing)에 관한 설명으로 옳은 것은? (옳은 것 고르기)

• ① 다중 프로그래밍 정도가 낮을수록 발생한다
• ② 스래싱 발생 시 CPU 이용률이 증가한다
• ③ 워킹셋은 스래싱 방지 도구 중 하나다
• ④ PFF와 워킹셋은 동일한 사상이다

한 장 요약

🎯 합격 한 끗: ★페고내·세가외★(페이징=고정→내부 / 세그먼테이션=가변→외부) + ★FLLON OS★ 6종(시간/횟수/이론/근사/2차 기회) + Belady(FIFO 단독) + EAT 계산(단위 환산 ms→ns) + 스래싱 방지(워킹셋·PFF) 세 축이 36강 출제의 거의 전부다. 매 회차 계산 1문항(FIFO·LRU 부재 횟수)이 굳어 나오니 손풀이 5단계를 손에 익혀두자. 35강 ★고내가외★가 36강 ★페고내·세가외★로 확장됐듯, 36강 페이지 교체 6종 ★FLLON OS★는 37강 디스크 스케줄링 ★FSSCL★과 짝을 이룬다(메모리 → 디스크).