메모리 관리

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>

/* ── malloc: Heap 영역 동적 할당 (내부적으로 sbrk/mmap 사용) ── */
void demo_malloc() {
    size_t size = 16 * 1024;  // 16KB (작은 할당 — 모두 128KB 미만이라 힙에 연속 배치)

    void *p1 = malloc(size);   // 연속 16KB 요청
    void *p2 = malloc(size * 2); // 연속 32KB 요청
    void *p3 = malloc(size / 2); // 연속 8KB 요청

    printf("p1: %p\np2: %p\np3: %p\n", p1, p2, p3);
    /* 주소를 보면 p1→p2→p3 순으로 연속 배치됨 */

    free(p2);   // p2 해제 → p1과 p3 사이에 '구멍' 발생 (외부 단편화)

    void *p4 = malloc(640 * 1024); // 640KB(128KB 초과): glibc는 내부적으로 mmap 사용
    // p4의 주소가 p1·p3와 전혀 다른 영역 — 페이지 단위로 분리 배치
    printf("p4: %p\n", p4);

    free(p1); free(p3); free(p4);
}

/* ── mmap: OS에 직접 페이지 단위 메모리 요청 ────────────────── */
void demo_mmap() {
    size_t page = 4096;   // 일반적인 페이지 크기 4KB

    // MAP_ANONYMOUS: 파일 없이 순수 메모리 할당 (페이징 직접 사용)
    void *mem = mmap(NULL, page * 5,
                     PROT_READ | PROT_WRITE,
                     MAP_PRIVATE | MAP_ANONYMOUS,
                     -1, 0);

    if (mem == MAP_FAILED) { perror("mmap"); return; }

    memset(mem, 0, page * 5);
    printf("mmap 주소: %p (페이지 정렬됨)\n", mem);
    // 주소가 항상 페이지 크기(4096)의 배수 → 페이징 단위로 관리

    munmap(mem, page * 5); // 해제: 프레임 반환
}

int main() {
    demo_malloc();
    demo_mmap();
    return 0;
}

import java.util.*;

/**
 * 페이지 테이블 시뮬레이션
 * 실제 OS의 페이지 테이블 동작을 단순화해 구현합니다.
 */
public class PagingSimulator {

    static final int PAGE_SIZE  = 64;   // 64KB (단위 생략)
    static final int N_FRAMES   = 8;    // 물리 메모리: 8 프레임

    // 물리 프레임 테이블: -1 = 빈 프레임, 그 외 = 점유한 PID
    static int[] frames = new int[N_FRAMES];

    // 프로세스별 페이지 테이블: pid → (논리 페이지 → 물리 프레임)
    static Map<Integer, Map<Integer, Integer>> pageTables = new HashMap<>();

    static {
        Arrays.fill(frames, -1); // 초기화: 모든 프레임 비어 있음
    }

    /** 프로세스에 필요한 페이지 수만큼 프레임을 비연속 할당 */
    static boolean allocate(int pid, int sizeKB) {
        int pages = (int) Math.ceil((double) sizeKB / PAGE_SIZE);
        Map<Integer, Integer> table = new LinkedHashMap<>();

        int page = 0;
        for (int f = 0; f < N_FRAMES && page < pages; f++) {
            if (frames[f] == -1) {        // 빈 프레임 발견
                frames[f] = pid;          // 프레임 점유
                table.put(page++, f);   // 논리 페이지 → 물리 프레임 매핑
            }
        }

        if (page < pages) {               // 프레임 부족
            table.keySet().forEach(p -> frames[table.get(p)] = -1);
            return false;
        }

        pageTables.put(pid, table);
        System.out.printf("P%d 할당 (%dKB, %d 페이지): %s%n",
            pid, sizeKB, pages, table);
        return true;
    }

    /** 논리 주소 → 물리 주소 변환 (MMU 역할) */
    static int translate(int pid, int logicalAddr) {
        int pageNum  = logicalAddr / PAGE_SIZE;  // 논리 페이지 번호
        int offset   = logicalAddr % PAGE_SIZE;  // 페이지 내 오프셋
        int frameNum = pageTables.get(pid).get(pageNum); // 페이지 테이블 조회
        return frameNum * PAGE_SIZE + offset;    // 물리 주소
    }

    public static void main(String[] args) {
        allocate(1, 128); // P1: 128KB = 2 페이지 → F0, F1
        allocate(2, 256); // P2: 256KB = 4 페이지 → F2~F5
        allocate(3, 64);  // P3: 64KB  = 1 페이지 → F6

        // P2 종료 → 프레임 해제
        pageTables.get(2).values().forEach(f -> frames[f] = -1);
        pageTables.remove(2);
        System.out.println("P2 해제 후 프레임: " + Arrays.toString(frames));

        // P4: 320KB = 5 페이지 → 비연속으로 F2,F3,F4,F5,F7 할당 성공!
        allocate(4, 320);

        // 논리 주소 변환 예시
        System.out.printf("P4 논리주소 200 → 물리주소 %d%n", translate(4, 200));
    }
}