/* コード例1: プロセスメモリレイアウトの確認 (Linux) */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
 
/* グローバル変数 → データセグメント or BSS */
int initialized_global = 42;       /* データセグメント（初期化済み） */
int uninitialized_global;          /* BSS セグメント（ゼロ初期化） */
const char *string_literal = "Hello, Memory!";  /* テキストセグメント */
 
void demonstrate_layout(void) {
    /* ローカル変数 → スタック */
    int stack_var = 100;
    char stack_array[64];
 
    /* 動的割り当て → ヒープ */
    int *heap_var = (int *)malloc(sizeof(int) * 256);
    if (!heap_var) {
        perror("malloc failed");
        return;
    }
 
    /* 静的ローカル変数 → データセグメント */
    static int static_local = 55;
 
    printf("=== メモリレイアウト確認 ===\n");
    printf("テキスト (関数アドレス):       %p\n", (void *)demonstrate_layout);
    printf("テキスト (文字列リテラル):     %p\n", (void *)string_literal);
    printf("データ  (初期化済みグローバル): %p\n", (void *)&initialized_global);
    printf("データ  (静的ローカル):         %p\n", (void *)&static_local);
    printf("BSS    (未初期化グローバル):   %p\n", (void *)&uninitialized_global);
    printf("ヒープ  (malloc):              %p\n", (void *)heap_var);
    printf("スタック (ローカル変数):        %p\n", (void *)&stack_var);
    printf("スタック (配列):               %p\n", (void *)stack_array);
    printf("Program Break (brk):           %p\n", sbrk(0));
 
    free(heap_var);
}
 
int main(void) {
    demonstrate_layout();
 
    /* /proc/self/maps で詳細なメモリマップを確認 */
    printf("\n=== /proc/self/maps (抜粋) ===\n");
    char cmd[64];
    snprintf(cmd, sizeof(cmd), "cat /proc/%d/maps | head -20", getpid());
    system(cmd);
 
    return 0;
}

/* brk(): Program Break を指定アドレスに設定 */
int brk(void *addr);
 
/* sbrk(): Program Break を increment バイト移動し、旧アドレスを返す */
void *sbrk(intptr_t increment);

/* mmap(): 仮想アドレス空間に新しいマッピングを作成 */
void *mmap(void *addr, size_t length, int prot, int flags,
           int fd, off_t offset);
 
/* munmap(): マッピングを解放 */
int munmap(void *addr, size_t length);

/* コード例2: malloc/free のヘッダ構造（簡略版） */
 
/*
 * malloc が返すポインタの直前に、管理用ヘッダが置かれる。
 * このヘッダには、ブロックサイズや使用/空きフラグが格納される。
 *
 *    malloc(24) が返すメモリブロック:
 *
 *    ┌──────────────────┬───────────────────────────┐
 *    │  ヘッダ (8-16B)  │    ユーザデータ (24B)      │
 *    │  size | flags    │    ← malloc() の戻り値    │
 *    └──────────────────┴───────────────────────────┘
 *    ↑                  ↑
 *    実際の開始位置       ユーザに返されるポインタ
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
 
/* 簡易アロケータのブロックヘッダ */
typedef struct block_header {
    size_t size;              /* ブロックサイズ（ヘッダ含む） */
    int is_free;              /* 0: 使用中, 1: 空き */
    struct block_header *next; /* 次のブロックへのポインタ */
} block_header_t;
 
#define HEADER_SIZE sizeof(block_header_t)
#define ALIGN(size) (((size) + 7) & ~7)  /* 8バイトアラインメント */
 
static block_header_t *free_list_head = NULL;
 
/* 簡易 malloc 実装 (First Fit) */
void *simple_malloc(size_t size) {
    if (size == 0) return NULL;
 
    size_t aligned_size = ALIGN(size);
    size_t total_size = HEADER_SIZE + aligned_size;
 
    /* フリーリストから適切なブロックを探索 (First Fit) */
    block_header_t *current = free_list_head;
    block_header_t *prev = NULL;
 
    while (current != NULL) {
        if (current->is_free && current->size >= total_size) {
            /* 十分な大きさの空きブロックを発見 */
 
            /* 分割可能なら分割する */
            if (current->size >= total_size + HEADER_SIZE + 8) {
                block_header_t *new_block =
                    (block_header_t *)((char *)current + total_size);
                new_block->size = current->size - total_size;
                new_block->is_free = 1;
                new_block->next = current->next;
 
                current->size = total_size;
                current->next = new_block;
            }
 
            current->is_free = 0;
            return (void *)((char *)current + HEADER_SIZE);
        }
        prev = current;
        current = current->next;
    }
 
    /* フリーリストに適切なブロックがない → sbrk で拡張 */
    block_header_t *new_block = (block_header_t *)sbrk(total_size);
    if (new_block == (void *)-1) {
        return NULL;  /* メモリ不足 */
    }
 
    new_block->size = total_size;
    new_block->is_free = 0;
    new_block->next = NULL;
 
    if (prev != NULL) {
        prev->next = new_block;
    } else {
        free_list_head = new_block;
    }
 
    return (void *)((char *)new_block + HEADER_SIZE);
}
 
/* 簡易 free 実装 */
void simple_free(void *ptr) {
    if (ptr == NULL) return;
 
    block_header_t *header =
        (block_header_t *)((char *)ptr - HEADER_SIZE);
    header->is_free = 1;
 
    /* 隣接する空きブロックの結合 (Coalescing) */
    block_header_t *current = free_list_head;
    while (current != NULL) {
        if (current->is_free && current->next != NULL
            && current->next->is_free) {
            /* 隣接する2つの空きブロックを結合 */
            current->size += current->next->size;
            current->next = current->next->next;
            continue;  /* さらに結合できる可能性 */
        }
        current = current->next;
    }
}

/* アラインメントを指定した割り当て */
#include <stdlib.h>
#include <stdio.h>
 
int main(void) {
    /* 64バイトアラインメント（キャッシュライン境界） */
    void *ptr = NULL;
    int ret = posix_memalign(&ptr, 64, 1024);
    if (ret != 0) {
        fprintf(stderr, "posix_memalign failed\n");
        return 1;
    }
    printf("64-byte aligned pointer: %p (%%64 == %lu)\n",
           ptr, (unsigned long)ptr % 64);
    free(ptr);
 
    /* C11 aligned_alloc (サイズはアラインメントの倍数であること) */
    void *ptr2 = aligned_alloc(32, 1024);
    printf("32-byte aligned pointer: %p (%%32 == %lu)\n",
           ptr2, (unsigned long)ptr2 % 32);
    free(ptr2);
 
    return 0;
}

/* コード例3: jemalloc の統計情報取得 */
#include <jemalloc/jemalloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main(void) {
    /* 様々なサイズのメモリを確保 */
    void *ptrs[1000];
    for (int i = 0; i < 1000; i++) {
        ptrs[i] = malloc(rand() % 4096 + 1);
    }
 
    /* 半分を解放（断片化を発生させる） */
    for (int i = 0; i < 1000; i += 2) {
        free(ptrs[i]);
        ptrs[i] = NULL;
    }
 
    /* jemalloc の統計情報を出力 */
    malloc_stats_print(NULL, NULL, NULL);
 
    /* 特定の統計値を取得 */
    size_t allocated, active, resident;
    size_t sz = sizeof(size_t);
 
    mallctl("stats.allocated", &allocated, &sz, NULL, 0);
    mallctl("stats.active", &active, &sz, NULL, 0);
    mallctl("stats.resident", &resident, &sz, NULL, 0);
 
    printf("\n=== メモリ使用状況 ===\n");
    printf("割り当て済み (allocated): %zu bytes\n", allocated);
    printf("アクティブ   (active):    %zu bytes\n", active);
    printf("常駐         (resident):  %zu bytes\n", resident);
    printf("断片化率: %.2f%%\n",
           (1.0 - (double)allocated / active) * 100);
 
    /* 残りを解放 */
    for (int i = 1; i < 1000; i += 2) {
        free(ptrs[i]);
    }
 
    return 0;
}
/* コンパイル: gcc -o test test.c -ljemalloc */

# コード例4: カーネルメモリ情報の確認コマンド集
 
# --- 物理メモリ全体の状態 ---
cat /proc/meminfo
# MemTotal:       16384000 kB    ← 物理メモリ総量
# MemFree:         2048000 kB    ← 完全に空きのメモリ
# MemAvailable:    8192000 kB    ← 利用可能（キャッシュ含む）
# Buffers:          512000 kB    ← ブロックデバイスバッファ
# Cached:          4096000 kB    ← ページキャッシュ
# Slab:             256000 kB    ← SLABアロケータ合計
 
# --- Buddy Allocator の状態 ---
cat /proc/buddyinfo
# Node 0, zone   Normal  1024  512  256  128  64  32  16  8  4  2  1
 
# --- SLAB の詳細統計 ---
cat /proc/slabinfo | head -20
# name            <active_objs> <num_objs> <objsize> ...
# task_struct          512        520       6016     ...
# inode_cache         2048       2060        592     ...
# dentry              4096       4100        192     ...
 
# --- プロセスごとのメモリマップ ---
cat /proc/self/maps | head -10
# 55a3b2c00000-55a3b2c02000 r--p  ... /path/to/binary   (テキスト)
# 55a3b2c02000-55a3b2c04000 r-xp  ... /path/to/binary   (コード)
# 7ffd2e490000-7ffd2e4b2000 rw-p  ... [stack]           (スタック)
 
# --- メモリ使用量トップ10プロセス ---
ps aux --sort=-%mem | head -11
 
# --- vmstat でメモリ活動をモニタ ---
vmstat 1 5
# procs ---memory--- ---swap-- -----io---- -system-- ------cpu-----
#  r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs ...

# コード例5: Python における参照カウントと循環参照
 
import sys
import gc
 
# --- 参照カウントの確認 ---
a = [1, 2, 3]
print(f"参照カウント: {sys.getrefcount(a)}")  # 2 (a + getrefcount引数)
 
b = a  # 参照を追加
print(f"参照カウント: {sys.getrefcount(a)}")  # 3
 
del b  # 参照を削除
print(f"参照カウント: {sys.getrefcount(a)}")  # 2
 
# --- 循環参照の問題 ---
class Node:
    def __init__(self, name):
        self.name = name
        self.ref = None
    def __del__(self):
        print(f"  Node({self.name}) が回収されました")
 
# 循環参照を作成
node_a = Node("A")
node_b = Node("B")
node_a.ref = node_b  # A → B
node_b.ref = node_a  # B → A  ← 循環参照!
 
# 外部参照を削除しても参照カウントは 0 にならない
del node_a
del node_b
# → 参照カウントだけでは回収されない!
 
# Python の GC (世代別トレーシング) が循環参照を検出して回収
print("gc.collect() 呼び出し前:")
collected = gc.collect()
print(f"gc.collect() で回収されたオブジェクト: {collected}")
 
# --- gc の世代別統計 ---
print(f"\nGC 世代別閾値: {gc.get_threshold()}")  # (700, 10, 10)
print(f"GC 世代別カウント: {gc.get_count()}")
# 第0世代: 700 割り当て後に GC
# 第1世代: 第0世代 GC 10回ごとに GC
# 第2世代: 第1世代 GC 10回ごとに GC
 
# --- 弱参照による循環参照の回避 ---
import weakref
 
class SafeNode:
    def __init__(self, name):
        self.name = name
        self._ref = None
 
    @property
    def ref(self):
        if self._ref is not None:
            return self._ref()
        return None
 
    @ref.setter
    def ref(self, node):
        self._ref = weakref.ref(node) if node else None
 
safe_a = SafeNode("A")
safe_b = SafeNode("B")
safe_a.ref = safe_b
safe_b.ref = safe_a  # 弱参照なので循環参照にならない
 
del safe_a  # safe_b._ref() は None を返すようになる

/* コード例6: 固定サイズメモリプール実装 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
 
typedef struct memory_pool {
    size_t block_size;      /* 各ブロックのサイズ */
    size_t pool_size;       /* プール内のブロック数 */
    uint8_t *memory;        /* メモリ領域 */
    uint8_t *free_list;     /* フリーリストの先頭 */
    size_t allocated_count; /* 割り当て済みブロック数 */
} memory_pool_t;
 
/* プール初期化 */
memory_pool_t *pool_create(size_t block_size, size_t pool_size) {
    /* ブロックサイズはポインタサイズ以上が必要 */
    if (block_size < sizeof(void *)) {
        block_size = sizeof(void *);
    }
 
    memory_pool_t *pool = (memory_pool_t *)malloc(sizeof(memory_pool_t));
    pool->block_size = block_size;
    pool->pool_size = pool_size;
    pool->allocated_count = 0;
 
    /* 連続したメモリ領域を確保 */
    pool->memory = (uint8_t *)malloc(block_size * pool_size);
 
    /* フリーリストを構築（各ブロックの先頭に次のブロックへのポインタ） */
    pool->free_list = pool->memory;
    for (size_t i = 0; i < pool_size - 1; i++) {
        uint8_t *current = pool->memory + i * block_size;
        uint8_t *next = pool->memory + (i + 1) * block_size;
        *(uint8_t **)current = next;
    }
    /* 最後のブロックの次は NULL */
    *(uint8_t **)(pool->memory + (pool_size - 1) * block_size) = NULL;
 
    return pool;
}
 
/* ブロック取得 O(1) */
void *pool_alloc(memory_pool_t *pool) {
    if (pool->free_list == NULL) {
        return NULL;  /* プール枯渇 */
    }
    void *block = pool->free_list;
    pool->free_list = *(uint8_t **)pool->free_list;
    pool->allocated_count++;
    return block;
}
 
/* ブロック返却 O(1) */
void pool_free(memory_pool_t *pool, void *block) {
    *(uint8_t **)block = pool->free_list;
    pool->free_list = (uint8_t *)block;
    pool->allocated_count--;
}
 
/* プール破棄 */
void pool_destroy(memory_pool_t *pool) {
    free(pool->memory);
    free(pool);
}
 
/* 使用例: ゲームエンジンのパーティクルシステム */
typedef struct particle {
    float x, y, z;
    float vx, vy, vz;
    float lifetime;
    int active;
} particle_t;
 
int main(void) {
    /* 10000 個のパーティクル用プールを作成 */
    memory_pool_t *particle_pool =
        pool_create(sizeof(particle_t), 10000);
 
    printf("プール作成: ブロックサイズ=%zu, 容量=%zu\n",
           particle_pool->block_size, particle_pool->pool_size);
 
    /* パーティクルを高速に割り当て */
    particle_t *particles[100];
    for (int i = 0; i < 100; i++) {
        particles[i] = (particle_t *)pool_alloc(particle_pool);
        particles[i]->x = (float)i;
        particles[i]->active = 1;
    }
 
    printf("割り当て済み: %zu\n", particle_pool->allocated_count);
 
    /* パーティクルを返却 */
    for (int i = 0; i < 100; i++) {
        pool_free(particle_pool, particles[i]);
    }
 
    printf("返却後: %zu\n", particle_pool->allocated_count);
 
    pool_destroy(particle_pool);
    return 0;
}

# Huge Pages の確認と設定
cat /proc/meminfo | grep Huge
# HugePages_Total:     128
# HugePages_Free:       64
# HugePages_Rsvd:       32
# Hugepagesize:       2048 kB
 
# Transparent Huge Pages (THP) の状態確認
cat /sys/kernel/mm/transparent_hugepage/enabled
# [always] madvise never
 
# データベース（Redis, PostgreSQL）では THP を無効にすることが多い
# → レイテンシのばらつき（THP のコンパクション処理）を避けるため

/* リーク検出対象のサンプルコード (leak_example.c) */
#include <stdlib.h>
#include <string.h>
 
void direct_leak(void) {
    /* 直接リーク: malloc したが free しない */
    int *data = (int *)malloc(sizeof(int) * 100);
    data[0] = 42;
    /* free(data) を忘れている! */
}
 
void indirect_leak(void) {
    /* 間接リーク: リンクリストのヘッドを失う */
    struct node {
        int value;
        struct node *next;
    };
 
    struct node *head = (struct node *)malloc(sizeof(struct node));
    head->value = 1;
    head->next = (struct node *)malloc(sizeof(struct node));
    head->next->value = 2;
    head->next->next = NULL;
 
    /* head のみ free → head->next がリーク */
    /* 正しくは: リスト全体をトラバースして free */
    free(head);  /* head->next は間接リーク */
}
 
int main(void) {
    direct_leak();
    indirect_leak();
    return 0;
}

# --- Valgrind でメモリリーク検出 ---
gcc -g -O0 leak_example.c -o leak_example
valgrind --leak-check=full --show-leak-kinds=all ./leak_example
 
# Valgrind 出力例:
# ==12345== HEAP SUMMARY:
# ==12345==   in use at exit: 416 bytes in 2 blocks
# ==12345==   total heap usage: 3 allocs, 1 frees, 432 bytes allocated
# ==12345==
# ==12345== 400 bytes in 1 blocks are definitely lost
# ==12345==    at 0x4C2FB0F: malloc (in /usr/lib/valgrind/...)
# ==12345==    by 0x401156: direct_leak (leak_example.c:6)
# ==12345==    by 0x4011A3: main (leak_example.c:32)
# ==12345==
# ==12345== 16 bytes in 1 blocks are indirectly lost
# ==12345==    at 0x4C2FB0F: malloc (in /usr/lib/valgrind/...)
# ==12345==    by 0x401178: indirect_leak (leak_example.c:17)
 
# --- AddressSanitizer (ASan) でメモリエラー検出 ---
gcc -fsanitize=address -fno-omit-frame-pointer -g leak_example.c -o leak_asan
./leak_asan
 
# --- LeakSanitizer を単独で使用 ---
gcc -fsanitize=leak -g leak_example.c -o leak_lsan
./leak_lsan

// コード例7: JavaScript における典型的なメモリリークパターン
 
// --- パターン1: イベントリスナーの未解除 ---
class LeakyComponent {
    constructor() {
        this.data = new Array(1000000).fill('x'); // 大きなデータ
        // イベントリスナーを登録
        this.handler = () => this.handleResize();
        window.addEventListener('resize', this.handler);
    }
 
    handleResize() {
        console.log('resize', this.data.length);
    }
 
    // destroy を呼び忘れるとリーク
    destroy() {
        window.removeEventListener('resize', this.handler);
    }
}
 
// --- パターン2: クロージャによるキャプチャ ---
function createLeak() {
    const hugeArray = new Array(1000000).fill('leak');
 
    // この関数が生きている限り hugeArray も保持される
    return function() {
        // hugeArray を直接使わなくても、
        // 同じスコープの変数がキャプチャされることがある
        console.log('closure alive');
    };
}
 
// --- パターン3: 無制限キャッシュ ---
const cache = new Map();
function addToCache(key, value) {
    // キャッシュが無限に成長する
    cache.set(key, value);
}
 
// 修正: WeakMap または LRU キャッシュを使用
const weakCache = new WeakMap(); // キーがGCされるとエントリも消える
 
// 修正: LRU キャッシュ（最大サイズ制限付き）
class LRUCache {
    constructor(maxSize) {
        this.maxSize = maxSize;
        this.cache = new Map();
    }
 
    get(key) {
        if (this.cache.has(key)) {
            const value = this.cache.get(key);
            this.cache.delete(key);
            this.cache.set(key, value); // 末尾に移動
            return value;
        }
        return undefined;
    }
 
    set(key, value) {
        if (this.cache.has(key)) {
            this.cache.delete(key);
        } else if (this.cache.size >= this.maxSize) {
            // 最も古いエントリを削除
            const oldestKey = this.cache.keys().next().value;
            this.cache.delete(oldestKey);
        }
        this.cache.set(key, value);
    }
}
 
// --- Chrome DevTools でのデバッグ手順 ---
// 1. Memory タブ → "Take heap snapshot"
// 2. 操作を実行
// 3. 再度スナップショット取得
// 4. "Comparison" ビューで差分を確認
// 5. Retainers パネルで何がオブジェクトを保持しているか特定

// コード例8: Go のメモリプロファイリング
package main
 
import (
    "fmt"
    "net/http"
    _ "net/http/pprof" // pprof エンドポイントを有効化
    "runtime"
    "time"
)
 
// 意図的にメモリを蓄積するキャッシュ
var leakyCache = make(map[string][]byte)
 
func simulateWork() {
    for i := 0; ; i++ {
        // キャッシュに無制限追加（リークの原因）
        key := fmt.Sprintf("key-%d", i)
        leakyCache[key] = make([]byte, 1024) // 1KB ずつ蓄積
 
        if i%1000 == 0 {
            var m runtime.MemStats
            runtime.ReadMemStats(&m)
            fmt.Printf("Alloc=%v MiB, Sys=%v MiB, NumGC=%v\n",
                m.Alloc/1024/1024,
                m.Sys/1024/1024,
                m.NumGC,
            )
        }
        time.Sleep(time.Millisecond)
    }
}
 
func main() {
    // pprof HTTP サーバを起動
    go func() {
        fmt.Println("pprof: http://localhost:6060/debug/pprof/")
        http.ListenAndServe(":6060", nil)
    }()
 
    simulateWork()
}
 
// プロファイリングコマンド:
// go tool pprof http://localhost:6060/debug/pprof/heap
// (pprof) top 10        ← メモリ使用量トップ10
// (pprof) web           ← グラフをブラウザで表示
// (pprof) list main     ← ソースコード注釈付き表示

// コード例9: C++ スマートポインタによるメモリ管理
#include <memory>
#include <vector>
#include <iostream>
 
class Resource {
public:
    Resource(int id) : id_(id) {
        std::cout << "Resource " << id_ << " acquired\n";
    }
    ~Resource() {
        std::cout << "Resource " << id_ << " released\n";
    }
    void use() { std::cout << "Using Resource " << id_ << "\n"; }
private:
    int id_;
};
 
void demonstrate_smart_pointers() {
    // --- unique_ptr: 排他的所有権（コピー不可、ムーブのみ） ---
    {
        auto r1 = std::make_unique<Resource>(1);
        r1->use();
        // スコープ終了時に自動解放
        // auto r2 = r1;  // コンパイルエラー! コピー不可
        auto r2 = std::move(r1);  // ムーブは可能
        // r1 は nullptr になる
    } // r2 のデストラクタが Resource を解放
 
    // --- shared_ptr: 共有所有権（参照カウント） ---
    {
        auto r3 = std::make_shared<Resource>(3);
        std::cout << "ref count: " << r3.use_count() << "\n"; // 1
 
        {
            auto r4 = r3;  // 共有
            std::cout << "ref count: " << r3.use_count() << "\n"; // 2
        } // r4 スコープ終了: カウント 2→1
 
        std::cout << "ref count: " << r3.use_count() << "\n"; // 1
    } // r3 スコープ終了: カウント 1→0 → 解放
 
    // --- weak_ptr: 循環参照の防止 ---
    {
        auto parent = std::make_shared<Resource>(5);
        std::weak_ptr<Resource> weak_ref = parent;
 
        if (auto locked = weak_ref.lock()) {
            locked->use();  // まだ有効
        }
 
        parent.reset();  // 解放
 
        if (auto locked = weak_ref.lock()) {
            locked->use();  // ここには到達しない
        } else {
            std::cout << "Resource already released\n";
        }
    }
 
    // --- unique_ptr + カスタムデリータ ---
    {
        auto file_deleter =  {
            if (f) {
                std::cout << "Closing file\n";
                fclose(f);
            }
        };
        std::unique_ptr<FILE, decltype(file_deleter)>
            file(fopen("/tmp/test.txt", "w"), file_deleter);
        if (file) {
            fprintf(file.get(), "Hello RAII\n");
        }
    } // ファイルは自動でクローズされる
}
 
int main() {
    demonstrate_smart_pointers();
    return 0;
}

// Go エスケープ解析の例
package main
 
import "fmt"
 
// スタックに配置される（関数外に参照が漏れない）
func stackAlloc() int {
    x := 42
    return x  // 値コピー → x はスタックに留まる
}
 
// ヒープに配置される（ポインタが関数外に漏れる = エスケープ）
func heapAlloc() *int {
    x := 42
    return &x  // ポインタが外に漏れる → x はヒープに配置
}
 
// インタフェース経由でエスケープ
func interfaceEscape() {
    x := 42
    fmt.Println(x)  // Println(interface{}) → x がエスケープ
}
 
// エスケープ解析の確認コマンド:
// go build -gcflags="-m -m" main.go
// ./main.go:13:2: x escapes to heap:
// ./main.go:13:2:   flow: ~r0 = &x:
// ./main.go:13:2:     from &x (address-of) at ./main.go:14:9

/* アンチパターン: 複数リソースの獲得と不完全な解放 */
int process_data_BAD(const char *filename) {
    FILE *file = fopen(filename, "r");
    if (!file) return -1;
 
    char *buffer = (char *)malloc(4096);
    if (!buffer) {
        /* file のクローズを忘れている! */
        return -1;
    }
 
    int *results = (int *)malloc(sizeof(int) * 1000);
    if (!results) {
        /* buffer の free を忘れている! */
        /* file のクローズも忘れている! */
        return -1;
    }
 
    /* ... 処理 ... */
 
    free(results);
    free(buffer);
    fclose(file);
    return 0;
}
 
/* 修正: goto による統一的なクリーンアップ（Linux カーネルスタイル） */
int process_data_GOOD(const char *filename) {
    int ret = -1;
    FILE *file = NULL;
    char *buffer = NULL;
    int *results = NULL;
 
    file = fopen(filename, "r");
    if (!file) goto cleanup;
 
    buffer = (char *)malloc(4096);
    if (!buffer) goto cleanup;
 
    results = (int *)malloc(sizeof(int) * 1000);
    if (!results) goto cleanup;
 
    /* ... 処理 ... */
    ret = 0;
 
cleanup:
    free(results);   /* free(NULL) は安全 */
    free(buffer);    /* free(NULL) は安全 */
    if (file) fclose(file);
    return ret;
}

/* アンチパターン: ループ内での繰り返し割り当て */
void process_items_BAD(int *items, int count) {
    for (int i = 0; i < count; i++) {
        /* 毎回 4KB の一時バッファを確保・解放 */
        char *tmp = (char *)malloc(4096);
        snprintf(tmp, 4096, "Processing item %d", items[i]);
        /* ... tmp を使った処理 ... */
        free(tmp);
        /* → count が 100万回なら、malloc/free が 100万回呼ばれる */
    }
}
 
/* 修正1: ループ外で一度だけ確保 */
void process_items_GOOD1(int *items, int count) {
    char *tmp = (char *)malloc(4096);
    if (!tmp) return;
 
    for (int i = 0; i < count; i++) {
        snprintf(tmp, 4096, "Processing item %d", items[i]);
        /* ... tmp を使った処理 ... */
    }
    free(tmp);
}
 
/* 修正2: サイズが固定なら VLA またはスタックを使用 */
void process_items_GOOD2(int *items, int count) {
    char tmp[4096];  /* スタック上に確保（固定サイズ） */
 
    for (int i = 0; i < count; i++) {
        snprintf(tmp, sizeof(tmp), "Processing item %d", items[i]);
        /* ... tmp を使った処理 ... */
    }
    /* 自動的に解放される */
}

#include <stdlib.h>
#include <string.h>
 
int global_initialized = 42;        /* → ? */
int global_uninitialized;           /* → ? */
const char *literal = "hello";      /* → ? (ポインタ自体は?) */
 
void function_example(int param) {  /* param → ? */
    int local = 10;                 /* → ? */
    static int persistent = 5;     /* → ? */
    int *dynamic = malloc(100);    /* dynamic → ?, *dynamic → ? */
    char buf[256];                 /* → ? */
 
    free(dynamic);
}

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
typedef struct {
    char *name;
    int *scores;
    int score_count;
} Student;
 
Student *create_student(const char *name, int count) {
    Student *s = (Student *)malloc(sizeof(Student));
    s->name = strdup(name);
    s->scores = (int *)malloc(sizeof(int) * count);
    s->score_count = count;
    return s;
}
 
void process_students(void) {
    Student *alice = create_student("Alice", 5);
    Student *bob = create_student("Bob", 3);
 
    /* Alice のスコアを設定 */
    for (int i = 0; i < alice->score_count; i++) {
        alice->scores[i] = 80 + i;
    }
 
    /* エラーが発生した場合の早期リターン */
    if (alice->scores[0] < 50) {
        free(alice);  /* リーク! name と scores を free していない */
        return;       /* bob もリーク! */
    }
 
    /* Bob の名前を変更 */
    bob->name = strdup("Robert");  /* リーク! 元の "Bob" が漏れる */
 
    free(alice->scores);
    free(alice->name);
    free(alice);
    free(bob->scores);
    free(bob->name);
    free(bob);
}

# jemalloc に差し替えて実行
LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libjemalloc.so ./my_program
 
# tcmalloc に差し替えて実行
LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libtcmalloc.so ./my_program

# 現在のプロセスの OOM スコアを確認
cat /proc/self/oom_score
 
# 重要なプロセスを OOM Killer から保護
echo -1000 > /proc/$(pidof my_database)/oom_score_adj