オペレーティングシステム完全ガイド: プロセス・メモリ・ファイルシステムから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) {
    // 優先度が高いほど vruntim の増加が遅くなる
    u64 weight = prio_to_weight[task->nice + 20];
    task->vruntime += delta_exec * NICE_0_WEIGHT / weight;
}

高優先度 H ────────────────────→ 待機中 (lockが必要)
中優先度 M ──────────────────→ Hより先に実行!
低優先度 L ──→ lockを保有中 ──→ プリエンプトされる

仮想アドレス (x86-64 の 48ビット):
┌──────────┬──────────┬──────────┬──────────┬────────────┐
│  PGD(9)  │  PUD(9)  │  PMD(9)  │  PTE(9)  │ offset(12) │
└──────────┴──────────┴──────────┴──────────┴────────────┘

クロックアルゴリズム:
  各ページに参照ビット(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

# 残りinode数を確認 (inode枯渇もディスク満杯と同じ効果)
df -i /

書き込み前: ジャーナルに変更内容を先に記録 (Write-Ahead Log)
書き込み後: 実際のブロックに反映
完了後:     ジャーナルエントリを削除 (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

# Pythonプロセスの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

# NVIDIA MIG + cgroupsの組み合わせでGPU分離
# 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"