メモリとパフォーマンス最適化の基礎——アプリケーション高速化の原則

// メイン関数に追加
import (
    "net/http"
    _ "net/http/pprof"
)

func main() {
    // pprof エンドポイントを起動
    go http.ListenAndServe("localhost:6060", nil)

    // アプリケーション処理
    runApplication()
}

# CPU プロファイル収集
go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30

# ヒーププロファイル
go tool pprof http://localhost:6060/debug/pprof/heap

# フレームグラフ表示
(pprof) web

// 高頻度割り当てオブジェクトを再利用
var bufferPool = sync.Pool{
    New: func() interface{} {
        return make([]byte, 4096)
    },
}

func process() {
    buf := bufferPool.Get().([]byte)
    defer bufferPool.Put(buf)
    // buf を使用
}

// ❌ 成長に伴い再割り当て
var result []int
for i := 0; i < 1000000; i++ {
    result = append(result, i)
}

// ○ 事前確保
result := make([]int, 0, 1000000)
for i := 0; i < 1000000; i++ {
    result = append(result, i)
}

// ❌ ポインタ渡し（ヒープ割り当て）
func process(data *LargeStruct) {
    // 読み取りのみ
}

// ○ 値渡し（スタックコピー）
func process(data LargeStruct) {
    // 読み取りのみ
}

// ❌ 全量メモリ読み込み
data, _ := ioutil.ReadFile("large.txt")
process(data) // 数 GB

// ○ ストリーミング
file, _ := os.Open("large.txt")
scanner := bufio.NewScanner(file)
for scanner.Scan() {
    process(scanner.Bytes()) // 1 行ずつ
}

// ❌ O(n²)
func findDuplicates(items []int) []int {
    var duplicates []int
    for i := 0; i < len(items); i++ {
        for j := i + 1; j < len(items); j++ {
            if items[i] == items[j] {
                duplicates = append(duplicates, items[i])
            }
        }
    }
    return duplicates
}

// ○ O(n)
func findDuplicatesOptimized(items []int) []int {
    seen := make(map[int]bool)
    var duplicates []int
    for _, item := range items {
        if seen[item] {
            duplicates = append(duplicates, item)
        }
        seen[item] = true
    }
    return duplicates
}

// ❌ キャッシュ非効率（間接参照）
type Node struct {
    Value int
    Next  *Node
}
// メモリ上に散在、ポインタ chasing

// ○ キャッシュ効率的（連続メモリ）
type Array struct {
    Values []int
}
// 連続メモリ、プリフェッチ効果

// シリアル処理（遅い）
func processAll(items []int) []int {
    results := make([]int, len(items))
    for i, item := range items {
        results[i] = heavyComputation(item)
    }
    return results
}

// 並列処理（速い）
func processAllParallel(items []int) []int {
    results := make([]int, len(items))
    numWorkers := runtime.NumCPU()
    chunkSize := (len(items) + numWorkers - 1) / numWorkers

    var wg sync.WaitGroup
    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go func(start int) {
            defer wg.Done()
            end := start + chunkSize
            if end > len(items) {
                end = len(items)
            }
            for j := start; j < end; j++ {
                results[j] = heavyComputation(items[j])
            }
        }(i * chunkSize)
    }
    wg.Wait()
    return results
}

// ❌ 都度書き込み（遅い）
for i := 0; i < 1000000; i++ {
    file.Write([]byte(fmt.Sprintf("%d\n", i)))
}

// ○ バッファリング
writer := bufio.NewWriter(file)
for i := 0; i < 1000000; i++ {
    writer.WriteString(fmt.Sprintf("%d\n", i))
}
writer.Flush() // 最後に一括書き込み

# シンクロナス（遅い）
import requests
urls = [...]
for url in urls:
    response = requests.get(url)  # 順番待ち
    process(response)

# アシンクロナス（速い）
import aiohttp
import asyncio

async def fetch(session, url):
    async with session.get(url) as response:
        return await process(response)

async def main():
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, url) for url in urls]
        results = await asyncio.gather(*tasks)  # 並列実行

# ❌ 都度接続
for url in urls:
    with requests.get(url) as response:
        process(response)
    # 接続クローズ

# ○ プーリング
session = requests.Session()
adapter = HTTPAdapter(pool_connections=10, pool_maxsize=100)
session.mount('http://', adapter)

for url in urls:
    with session.get(url) as response:
        process(response)
# 接続再利用

from functools import lru_cache

@lru_cache(maxsize=1000)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# 初回計算：O(2^n) → キャッシュ後：O(1)

def get_user(user_id):
    # 1. キャッシュ確認
    user = cache.get(f"user:{user_id}")
    if user:
        return user

    # 2. DB から取得
    user = db.query("SELECT * FROM users WHERE id = ?", user_id)

    # 3. キャッシュに保存
    cache.set(f"user:{user_id}", user, ttl=3600)

    return user