MessWithDNSでのIPアドレス検索におけるメモリ使用量の削減

import (
    "runtime"
    "runtime/pprof"
    "os"
)

func dumpHeapProfile(path string) error {
    runtime.GC() // force GC so the profile reflects live allocations
    f, err := os.Create(path)
    if err != nil {
        return err
    }
    defer f.Close()
    return pprof.WriteHeapProfile(f)
}

# capture a heap profile from a running process
go tool pprof -alloc_space http://localhost:6060/debug/pprof/heap

# or from a saved file
go tool pprof -inuse_space heap.prof

type IPRange struct {
    Start   net.IP // byte slice: 24 bytes header + 16 bytes data
    End     net.IP
    Country string
    ASN     uint32
    OrgName string // "Cloudflare, Inc." — duplicated for every range
    OrgDesc string // duplicated again
}

var ranges []IPRange // 500,000+ entries

type ASNRecord struct {
    OrgName string
    OrgDesc string
    Country string
    ASN     uint32
}

type IPRange struct {
    Start   netip.Addr // value type — no heap allocation
    End     netip.Addr
    ASNIdx  uint32 // index into a shared ASNRecord slice
}

var asnRecords []ASNRecord // one entry per unique ASN
var ranges []IPRange       // many entries, tiny per-entry cost

func buildIndex(rows []rawRow) ([]IPRange, []ASNRecord) {
    asnMap := make(map[uint32]uint32) // ASN number -> index
    var asnRecords []ASNRecord
    var ranges []IPRange

    for _, row := range rows {
        idx, ok := asnMap[row.ASN]
        if !ok {
            idx = uint32(len(asnRecords))
            asnRecords = append(asnRecords, ASNRecord{
                OrgName: row.OrgName,
                OrgDesc: row.OrgDesc,
                Country: row.Country,
                ASN:     row.ASN,
            })
            asnMap[row.ASN] = idx
        }
        ranges = append(ranges, IPRange{
            Start:  row.Start,
            End:    row.End,
            ASNIdx: idx,
        })
    }
    return ranges, asnRecords
}

// Before: heap allocation per address
start := net.ParseIP("2a06:98c0::")  // []byte on heap

// After: pure stack value
start, _ := netip.ParseAddr("2a06:98c0::")  // no heap

func lookup(ranges []IPRange, ip netip.Addr) *ASNRecord {
    lo, hi := 0, len(ranges)-1
    for lo <= hi {
        mid := (lo + hi) / 2
        r := ranges[mid]
        if ip.Compare(r.Start) >= 0 && ip.Compare(r.End) <= 0 {
            return &asnRecords[r.ASNIdx]
        }
        if ip.Compare(r.Start) < 0 {
            hi = mid - 1
        } else {
            lo = mid + 1
        }
    }
    return nil
}

BEFORE (per IPRange, with net.IP):
┌──────────────────────────────────────────┐
│ Start  net.IP  [ptr|len|cap] = 24 bytes  │
│         heap → [16 bytes]                │
│ End    net.IP  [ptr|len|cap] = 24 bytes  │
│         heap → [16 bytes]                │
│ Country string  16 bytes                 │
│ ASN     uint32   4 bytes                 │
│ OrgName string  16 bytes + heap string   │
│ OrgDesc string  16 bytes + heap string   │
└──────────────────────────────────────────┘
~120+ bytes per entry (plus heap strings)

AFTER (per IPRange, with netip.Addr):
┌──────────────────────────────────────────┐
│ Start  netip.Addr  17 bytes (no heap)    │
│ End    netip.Addr  17 bytes (no heap)    │
│ ASNIdx uint32       4 bytes              │
└──────────────────────────────────────────┘
~38 bytes per entry (all inline, no heap)

# Quick benchmark template
func BenchmarkLookup(b *testing.B) {
    ip, _ := netip.ParseAddr("1.1.1.1")
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        lookup(ranges, ip)
    }
}