[운영체제] 09. 메인 메모리 관리

CPU <-> 레지스터 (~1ns) <-> 캐시 (~10ns) <-> 메인 메모리 (~100ns)

[주소 바인딩 시점]

1. 컴파일 시간 바인딩
   - 프로세스가 메모리의 어디에 올라갈지 컴파일 시 결정
   - 위치가 바뀌면 재컴파일 필요
   - 예: MS-DOS의 .COM 프로그램

2. 로드 시간 바인딩
   - 프로그램을 메모리에 올릴 때 주소 결정
   - 재배치 가능 코드(relocatable code) 사용
   - 로드 후 주소 변경 불가

3. 실행 시간 바인딩 (현대 OS)
   - 실행 중에 주소를 동적으로 변환
   - MMU(Memory Management Unit) 하드웨어 필요
   - 프로세스를 메모리 내에서 이동 가능

[MMU를 통한 주소 변환]

CPU --[논리적 주소: 346]--> MMU --[물리적 주소: 14346]--> 메모리
                            |
                      재배치 레지스터
                      (기준값: 14000)

물리적 주소 = 논리적 주소 + 재배치 레지스터 값
346 + 14000 = 14346

[정적 링킹 vs 동적 링킹]

정적 링킹:
  프로그램 A: [코드 + libc 복사본]   -- 50MB
  프로그램 B: [코드 + libc 복사본]   -- 50MB
  총 메모리: 100MB

동적 링킹 (공유 라이브러리):
  프로그램 A: [코드 + libc 참조]     -- 10MB
  프로그램 B: [코드 + libc 참조]     -- 10MB
  libc.so:   [공유 라이브러리]       -- 40MB
  총 메모리: 60MB

Linux: .so 파일 (Shared Object)
Windows: .dll 파일 (Dynamic-Link Library)

[기준 레지스터와 한계 레지스터]

     기준(base)              한계(limit)
        |                       |
        v                       v
+-------+=======================+-------+
| OS    | 프로세스 P의 영역      | 기타  |
+-------+=======================+-------+
  0     300040                 420940

CPU가 생성한 주소 addr에 대해:
  if (addr >= base && addr < base + limit)
      접근 허용 -> 물리 메모리 접근
  else
      트랩 발생 -> OS가 오류 처리

[메모리 할당 예시]

초기 상태:
|---OS---|--P1--|-------빈공간-------|--P3--|---빈공간---|

할당 전략:
1. 최초 적합(First Fit): 첫 번째로 충분한 빈 공간에 할당
   장점: 빠름

2. 최적 적합(Best Fit): 가장 작은 충분한 빈 공간에 할당
   장점: 작은 남은 공간 생성
   단점: 전체 탐색 필요, 매우 작은 조각 생성

3. 최악 적합(Worst Fit): 가장 큰 빈 공간에 할당
   장점: 남은 공간이 커서 재활용 가능
   단점: 전체 탐색 필요

[외부 단편화 vs 내부 단편화]

외부 단편화:
|P1|  빈  |P2| 빈 |P3|  빈  |P4|
    100KB     50KB     80KB

총 빈 공간: 230KB인데, 200KB 프로세스를 올릴 수 없음!
(연속 공간이 아니므로)

해결: 압축(Compaction) - 프로세스를 한쪽으로 이동
|P1|P2|P3|P4|-----230KB 빈 공간-----|

내부 단편화:
메모리를 고정 크기 블록으로 할당할 때
프로세스가 블록보다 작으면 내부에 남는 공간 발생

프로세스 크기: 18,462 바이트
할당 블록 크기: 20,000 바이트
내부 단편화: 1,538 바이트 낭비

[페이징 주소 변환]

논리적 주소 = 페이지 번호(p) + 페이지 오프셋(d)

예: 페이지 크기 4KB (2^12), 논리 주소 32비트
  상위 20비트 = 페이지 번호 (최대 2^20 = 1M 페이지)
  하위 12비트 = 오프셋 (0 ~ 4095)

+--------+--------+
| p (20) | d (12) |       논리적 주소
+--------+--------+
     |
     v
[페이지 테이블]
 p -> f (프레임 번호)
     |
     v
+--------+--------+
| f (20) | d (12) |       물리적 주소
+--------+--------+

[페이징 예시]

논리 메모리 (4페이지):        물리 메모리 (8프레임):
+------+                     +------+
|페이지0| ----+              |      | 프레임0
+------+     |              +------+
|페이지1| --+ |              |페이지2| 프레임1
+------+   | |              +------+
|페이지2| -+| |              |      | 프레임2
+------+  || |              +------+
|페이지3|  || +------------>|페이지0| 프레임3
+------+  ||                +------+
          |+--------------->|페이지1| 프레임4
          |                 +------+
          +---------------->|페이지2| 프레임5 (X)
                            +------+
                            |페이지3| 프레임6
                            +------+
                            |      | 프레임7
                            +------+

페이지 테이블:
  페이지0 -> 프레임3
  페이지1 -> 프레임4
  페이지2 -> 프레임1
  페이지3 -> 프레임6

[TLB를 통한 주소 변환]

CPU --논리 주소(p, d)--> TLB 검색
                          |
              +-----------+-----------+
              |                       |
          TLB 히트                 TLB 미스
          (빠름, ~1ns)             (느림)
              |                       |
          프레임 f 획득          페이지 테이블 조회
              |                  프레임 f 획득
              |                  TLB에 등록
              |                       |
              +----------+------------+
                         |
                  물리 주소 (f, d)로
                  메모리 접근

유효 접근 시간(EAT) 계산:
  TLB 히트율 = 99% (일반적)
  메모리 접근 시간 = 100ns
  TLB 접근 시간 = 10ns

  EAT = 0.99 * (10 + 100) + 0.01 * (10 + 100 + 100)
      = 0.99 * 110 + 0.01 * 210
      = 108.9 + 2.1
      = 111ns

  TLB 없이: 200ns (메모리 2번 접근)
  TLB 있으면: 111ns (44.5% 개선)

[2단계 페이지 테이블]

32비트 주소, 4KB 페이지:
+--------+--------+--------+
| p1(10) | p2(10) | d(12)  |
+--------+--------+--------+

외부 페이지 테이블 (1단계)
+---+
| 0 |---> 2단계 테이블 A
+---+      +---+
| 1 |--+   | 0 |--> 프레임 번호
+---+  |   +---+
| 2 |  |   | 1 |--> 프레임 번호
+---+  |   +---+
       |   | ...|
       |   +---+
       |
       +-> 2단계 테이블 B
           +---+
           | 0 |--> 프레임 번호
           +---+
           | ...|
           +---+

장점: 사용하지 않는 영역의 2단계 테이블은 생성하지 않음
-> 메모리 절약

[해시 페이지 테이블]

논리 페이지 번호 p를 해시 함수에 입력
-> 해시 테이블의 슬롯으로 매핑
-> 체인(연결 리스트)에서 p를 검색
-> 대응하는 프레임 번호 반환

64비트 주소 공간처럼 매우 큰 경우에 유용

[역 페이지 테이블]

일반 페이지 테이블: 프로세스당 하나 (논리 -> 물리)
역 페이지 테이블:   시스템에 하나 (물리 프레임 -> 프로세스, 페이지)

물리 메모리의 각 프레임에 대해 하나의 항목:
프레임 0: (PID=5, 페이지=3)
프레임 1: (PID=2, 페이지=7)
프레임 2: (비어 있음)
프레임 3: (PID=5, 페이지=0)
...

장점: 물리 메모리 크기에 비례하는 테이블 크기
단점: 주소 변환 시 전체 테이블 검색 필요 (해시로 해결)

[표준 스와핑]

메인 메모리                    백킹 스토어(디스크)
+---------+                   +---------+
|   OS    |                   |         |
+---------+                   |  P2의   |
|   P1    |  <-- swap in ---  |  이미지  |
+---------+                   |         |
|   P3    |  --- swap out --> |         |
+---------+                   +---------+
|   빈공간  |
+---------+

현대 시스템에서는 프로세스 전체가 아닌
페이지 단위로 스와핑 (페이지 스와핑)

[페이지 단위 스와핑]

프로세스의 특정 페이지만 디스크로 이동:
- 오랫동안 사용하지 않은 페이지를 swap out
- 필요할 때 다시 swap in
- 가상 메모리의 기반 기술

[페이지 테이블 항목의 구조]

+-------+-----+-----+-----+-------+
| 프레임 | 유효 | 읽기 | 쓰기 | 실행  |
| 번호   | 비트 | 가능 | 가능 | 가능  |
+-------+-----+-----+-----+-------+

유효 비트(Valid bit):
  1 = 이 페이지가 프로세스의 논리 주소 공간에 속함
  0 = 유효하지 않은 페이지 (접근 시 트랩 발생)

보호 비트:
  읽기 전용 페이지에 쓰기 시도 -> 하드웨어 트랩
  코드 페이지에 대해 실행만 허용, 쓰기 불허

// 메모리 보호 예시: mprotect 시스템 콜
#include <sys/mman.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

void segfault_handler(int sig) {
    printf("세그먼트 폴트 발생! 보호된 메모리 접근 시도\n");
    exit(1);
}

int main() {
    signal(SIGSEGV, segfault_handler);

    // 페이지 크기 단위로 메모리 할당
    size_t page_size = getpagesize();  // 보통 4096
    void *ptr = aligned_alloc(page_size, page_size);

    // 데이터 쓰기
    *(int *)ptr = 42;
    printf("값: %d\n", *(int *)ptr);

    // 메모리를 읽기 전용으로 보호
    mprotect(ptr, page_size, PROT_READ);

    // 쓰기 시도 -> 세그먼트 폴트!
    *(int *)ptr = 100;

    free(ptr);
    return 0;
}