운영체제 완전 정복: 프로세스/메모리/파일시스템부터 AI 워크로드 최적화까지

  생성(New) ──→ 준비(Ready) ──→ 실행(Running)
                   ↑               │
                   │    스케줄러    │ I/O 요청
                   └── 대기(Wait) ←┘
                         │
                         ↓
                    종료(Terminated)

// Linux의 task_struct (단순화)
struct task_struct {
    pid_t pid;              // 프로세스 ID
    int   state;            // 현재 상태
    struct mm_struct *mm;   // 가상 메모리 매핑
    struct files_struct *files; // 열린 파일 테이블
    struct thread_info thread_info; // 레지스터 저장
    long prio;              // 스케줄링 우선순위
};

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main(void) {
    pid_t pid = fork();

    if (pid < 0) {
        perror("fork 실패");
        return 1;
    } else if (pid == 0) {
        // 자식 프로세스
        char *args[] = {"/bin/ls", "-la", NULL};
        execv("/bin/ls", args);
        perror("exec 실패"); // exec 성공 시 여기 도달 안 함
    } else {
        // 부모 프로세스
        int status;
        waitpid(pid, &status, 0);
        printf("자식 종료 코드: %d\n", WEXITSTATUS(status));
    }
    return 0;
}

// vruntime 계산 (개념적 의사코드)
void update_vruntime(struct task_struct *task, u64 delta_exec) {
    // 우선순위가 높을수록 vruntime이 느리게 증가
    u64 weight = prio_to_weight[task->nice + 20];
    task->vruntime += delta_exec * NICE_0_WEIGHT / weight;
}

고우선순위 H ────────────────────→ 대기 중 (lock 필요)
중우선순위 M ──────────────────→ H보다 먼저 실행!
저우선순위 L ──→ lock 보유 중 ──→ preempt 당함

가상 주소 (48비트 on x86-64):
┌──────────┬──────────┬──────────┬──────────┬──────────┬────────────┐
│  PGD(9)  │  PUD(9)  │  PMD(9)  │  PTE(9)  │ offset(12)│           │
└──────────┴──────────┴──────────┴──────────┴──────────┴────────────┘

Clock 알고리즘:
  각 페이지마다 reference bit(R) 유지
  포인터가 순환하며 R=0인 페이지를 교체 대상으로 선택
  R=1이면 R=0으로 초기화 후 다음으로 이동

import mmap
import os

# 대용량 데이터셋을 메모리 맵으로 접근
with open("large_dataset.bin", "r+b") as f:
    # 파일 전체를 가상 주소 공간에 매핑
    mm = mmap.mmap(f.fileno(), 0)

    # 슬라이싱으로 원하는 영역만 접근 (실제 I/O는 필요할 때만)
    header = mm[:128]
    record = mm[128:256]

    mm.close()

# AI 학습: numpy memmap으로 디스크 데이터를 배열처럼 접근
import numpy as np
data = np.memmap("features.npy", dtype="float32", mode="r", shape=(1_000_000, 512))
batch = data[0:1024]  # 디스크에서 필요한 배치만 로드

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

#define BUFFER_SIZE 10

int buffer[BUFFER_SIZE];
int count = 0;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t  not_full  = PTHREAD_COND_INITIALIZER;
pthread_cond_t  not_empty = PTHREAD_COND_INITIALIZER;

void *producer(void *arg) {
    for (int i = 0; i < 50; i++) {
        pthread_mutex_lock(&mutex);
        while (count == BUFFER_SIZE)
            pthread_cond_wait(&not_full, &mutex);  // 버퍼 가득 찼으면 대기

        buffer[count++] = i;
        printf("생산: %d (count=%d)\n", i, count);
        pthread_cond_signal(&not_empty);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

void *consumer(void *arg) {
    for (int i = 0; i < 50; i++) {
        pthread_mutex_lock(&mutex);
        while (count == 0)
            pthread_cond_wait(&not_empty, &mutex);  // 버퍼 비면 대기

        int val = buffer[--count];
        printf("소비: %d (count=%d)\n", val, count);
        pthread_cond_signal(&not_full);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main(void) {
    pthread_t prod, cons;
    pthread_create(&prod, NULL, producer, NULL);
    pthread_create(&cons, NULL, consumer, NULL);
    pthread_join(prod, NULL);
    pthread_join(cons, NULL);
    return 0;
}

# inode 정보 확인
stat /etc/hostname
# File: /etc/hostname
# Size: 12        Blocks: 8   IO Block: 4096  regular file
# Inode: 131073   Links: 1
# Access: 2026-03-17 10:00:00
# Modify: 2026-01-01 00:00:00

# 남은 inode 수 확인 (inode 고갈도 디스크 꽉 찬 것과 같은 효과)
df -i /

쓰기 전: Journal에 변경 내용 먼저 기록 (Write-Ahead Log)
쓰기 후: 실제 블록에 반영
완료 후: Journal 항목 제거 (Commit)

사용자 공간:  open() read() write()
                    │
커널 VFS 계층: vfs_open() vfs_read()   ← 공통 인터페이스
                    │
파일 시스템:  ext4 | btrfs | tmpfs | procfs | nfs
                    │
블록 디바이스 계층 → 실제 하드웨어

1. CPU → DMA: "디스크 블록 X를 메모리 주소 Y에 복사해줘"
2. DMA가 독립적으로 전송 수행 (CPU는 다른 작업)
3. DMA 완료 → 인터럽트 발생
4. CPU: 현재 명령 완료 → 인터럽트 벡터 테이블 참조 → ISR 실행
5. ISR: 완료 처리 후 대기 중인 프로세스 깨움

// epoll 방식: 여전히 시스템콜이 필요
int epfd = epoll_create1(0);
epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &event);
epoll_wait(epfd, events, MAX_EVENTS, -1);  // 시스템콜
read(fd, buf, size);                        // 또 시스템콜

// io_uring: 시스템콜 없이 I/O 제출 가능
struct io_uring ring;
io_uring_queue_init(256, &ring, 0);

struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
io_uring_prep_read(sqe, fd, buf, size, 0);
io_uring_submit(&ring);  // 시스템콜 1번으로 여러 I/O 제출

// 완료 대기 (커널과 공유 메모리로 통신)
struct io_uring_cqe *cqe;
io_uring_wait_cqe(&ring, &cqe);

Socket 0              Socket 1
┌─────────┐          ┌─────────┐
│  CPU 0  │──QPI────│  CPU 1  │
│ 32GB RAM│          │ 32GB RAM│
└─────────┘          └─────────┘
로컬 접근: ~100ns    원격 접근: ~300ns

# NUMA 토폴로지 확인
numactl --hardware
# NUMA 통계 모니터링
numastat -p python

import time
import threading
import multiprocessing

def cpu_bound_task(n):
    """소수 계산 (CPU 집약적)"""
    count = 0
    for i in range(2, n):
        if all(i % j != 0 for j in range(2, int(i**0.5) + 1)):
            count += 1
    return count

N = 100_000

# 멀티스레딩: GIL 때문에 CPU 바운드에서 성능 향상 없음
start = time.time()
threads = [threading.Thread(target=cpu_bound_task, args=(N,)) for _ in range(4)]
[t.start() for t in threads]
[t.join() for t in threads]
print(f"스레딩: {time.time() - start:.2f}초")

# 멀티프로세싱: 별도 프로세스로 GIL 우회
start = time.time()
with multiprocessing.Pool(4) as pool:
    pool.map(cpu_bound_task, [N] * 4)
print(f"프로세싱: {time.time() - start:.2f}초")
# 결과: 프로세싱이 ~4배 빠름

# cgroups v2 설정으로 팀별 GPU 메모리 제한

# 팀 A 그룹 생성
mkdir /sys/fs/cgroup/team_a

# CPU 제한: 전체의 25%만 사용
echo "25000 100000" > /sys/fs/cgroup/team_a/cpu.max

# 메모리 제한: 16GB
echo $((16 * 1024 * 1024 * 1024)) > /sys/fs/cgroup/team_a/memory.max

# 프로세스를 그룹에 추가
echo $$ > /sys/fs/cgroup/team_a/cgroup.procs

# GPU 격리는 NVIDIA MIG + cgroups 조합
# MIG: 하나의 A100을 여러 인스턴스로 분할
nvidia-smi mig -cgi 3g.40gb -C  # 40GB 인스턴스 생성

# Docker로 GPU 자원 제한
docker run --gpus '"device=0,1"' \
  --cpuset-cpus="0-15" \
  --memory="32g" \
  pytorch/pytorch:latest python train.py

# 프로세스 메모리 매핑 확인
cat /proc/$(pgrep python)/maps

# 프로세스 상태 확인
cat /proc/$(pgrep python)/status | grep -E "VmRSS|VmPeak|Threads"

# CPU 스케줄링 통계
cat /proc/$(pgrep python)/schedstat

# NUMA 메모리 바인딩 확인
cat /proc/$(pgrep python)/numa_maps | head -20

# 시스템 전체 메모리 정보
cat /proc/meminfo | grep -E "MemTotal|MemFree|Cached|HugePages"