feat: add TLB/THP tracking, page reclaim detection, NUMA analysis, GPU/PCIe topology (#10)

Page Reclaim & THP (Tier 1):
- Parse /proc/vmstat: pgscan_direct/kswapd, pgsteal, allocstall,
  compact_stall/success/fail, thp_fault_alloc/collapse/split
- Two-point sampling for rate computation (direct_reclaim_rate,
  compact_stall_rate, thp_split_rate)
- Collect THP defrag mode, vm.watermark_scale_factor,
  dirty_expire/writeback_centisecs, zone_reclaim_mode
- Anomaly rules: direct_reclaim_rate, compaction_stall_rate, thp_split_rate
- Recommendations: watermark tuning, THP madvise, compaction fixes

NUMA Analysis:
- Compute miss_ratio per node from existing numa_hit/numa_miss data
- Collect NUMA distance matrix and CPU list per node
- Collect kernel.sched_numa_balancing sysctl
- Anomaly rule: numa_miss_ratio > 5% warning, > 20% critical
- Recommendation: numactl pinning, enable sched_numa_balancing

GPU & PCIe Topology (new Tier 1 collector):
- New GPUCollector: nvidia-smi query for GPU metrics (name, memory,
  utilization, temperature, power, PCI bus)
- PCI device → NUMA node mapping from /sys/bus/pci/devices/*/numa_node
- NIC → NUMA node mapping from /sys/class/net/*/device/numa_node
- Cross-NUMA pair detection (GPU on node N, NIC on node M)
- Anomaly rule: gpu_nic_cross_numa
- Model types: GPUDevice, PCIeTopology, CrossNUMAPair

Tests: 10 new test functions covering vmstat reclaim, rate computation,
GPU detection with mock nvidia-smi, cross-NUMA pair detection, NUMA miss ratio.

MCP explanations added for all 6 new anomaly IDs.

Co-authored-by: dmitriimaksimovdevelop <227611064+dmitriimaksimovdevelop@users.noreply.github.com>
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: dmitriimaksimovdevelop

internal/collector/gpu.go

@@ -0,0 +1,163 @@
+// GPU and PCIe topology collector (Tier 1).
+// Detects NVIDIA GPUs via nvidia-smi, maps PCI devices to NUMA nodes,
+// flags GPU-NIC pairs on different NUMA nodes.
+package collector
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/dmitriimaksimovdevelop/melisai/internal/model"
+)
+
+// GPUCollector detects GPUs and PCIe topology.
+type GPUCollector struct {
+	sysRoot string
+	cmdRun  CommandRunner
+}
+
+func NewGPUCollector(sysRoot string) *GPUCollector {
+	return &GPUCollector{sysRoot: sysRoot, cmdRun: &ExecCommandRunner{}}
+}
+
+func (c *GPUCollector) Name() string     { return "gpu_pcie" }
+func (c *GPUCollector) Category() string { return "system" }
+func (c *GPUCollector) Available() Availability {
+	return Availability{Tier: 1}
+}
+
+func (c *GPUCollector) Collect(ctx context.Context, cfg CollectConfig) (*model.Result, error) {
+	start := time.Now()
+	topo := &model.PCIeTopology{
+		NICNUMAMap: make(map[string]int),
+	}
+
+	// Detect NVIDIA GPUs via nvidia-smi
+	topo.GPUs = c.detectNvidiaGPUs(ctx)
+
+	// Build NIC → NUMA node map from sysfs
+	c.buildNICNUMAMap(topo)
+
+	// Find GPU-NIC cross-NUMA pairs
+	c.findCrossNUMAPairs(topo)
+
+	// Skip if nothing detected
+	if len(topo.GPUs) == 0 && len(topo.NICNUMAMap) == 0 {
+		return nil, nil
+	}
+
+	return &model.Result{
+		Collector: c.Name(),
+		Category:  c.Category(),
+		Tier:      1,
+		StartTime: start,
+		EndTime:   time.Now(),
+		Data:      topo,
+	}, nil
+}
+
+// detectNvidiaGPUs queries nvidia-smi for GPU information.
+func (c *GPUCollector) detectNvidiaGPUs(ctx context.Context) []model.GPUDevice {
+	// nvidia-smi --query-gpu=index,name,driver_version,pci.bus_id,memory.total,memory.used,utilization.gpu,utilization.memory,temperature.gpu,power.draw --format=csv,noheader,nounits
+	out, err := c.cmdRun.Run(ctx, "nvidia-smi",
+		"--query-gpu=index,name,driver_version,pci.bus_id,memory.total,memory.used,utilization.gpu,utilization.memory,temperature.gpu,power.draw",
+		"--format=csv,noheader,nounits")
+	if err != nil {
+		return nil // nvidia-smi not available
+	}
+
+	var gpus []model.GPUDevice
+	for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
+		fields := strings.Split(line, ", ")
+		if len(fields) < 4 {
+			continue
+		}
+		idx, _ := strconv.Atoi(strings.TrimSpace(fields[0]))
+		gpu := model.GPUDevice{
+			Index:  idx,
+			Name:   strings.TrimSpace(fields[1]),
+			Driver: strings.TrimSpace(fields[2]),
+			PCIBus: strings.TrimSpace(fields[3]),
+		}
+		if len(fields) > 4 {
+			gpu.MemoryTotal, _ = strconv.ParseInt(strings.TrimSpace(fields[4]), 10, 64)
+		}
+		if len(fields) > 5 {
+			gpu.MemoryUsed, _ = strconv.ParseInt(strings.TrimSpace(fields[5]), 10, 64)
+		}
+		if len(fields) > 6 {
+			gpu.UtilGPU, _ = strconv.Atoi(strings.TrimSpace(fields[6]))
+		}
+		if len(fields) > 7 {
+			gpu.UtilMemory, _ = strconv.Atoi(strings.TrimSpace(fields[7]))
+		}
+		if len(fields) > 8 {
+			gpu.Temperature, _ = strconv.Atoi(strings.TrimSpace(fields[8]))
+		}
+		if len(fields) > 9 {
+			pw, _ := strconv.ParseFloat(strings.TrimSpace(fields[9]), 64)
+			gpu.PowerWatts = int(pw)
+		}
+
+		// Get NUMA node from sysfs
+		gpu.NUMANode = c.pciNUMANode(gpu.PCIBus)
+
+		gpus = append(gpus, gpu)
+	}
+	return gpus
+}
+
+// buildNICNUMAMap maps each physical NIC to its NUMA node.
+func (c *GPUCollector) buildNICNUMAMap(topo *model.PCIeTopology) {
+	netDir := filepath.Join(c.sysRoot, "class", "net")
+	entries, err := os.ReadDir(netDir)
+	if err != nil {
+		return
+	}
+
+	for _, e := range entries {
+		name := e.Name()
+		if name == "lo" || strings.HasPrefix(name, "veth") || strings.HasPrefix(name, "docker") || strings.HasPrefix(name, "br-") {
+			continue
+		}
+		numaFile := filepath.Join(netDir, name, "device", "numa_node")
+		if data, err := os.ReadFile(numaFile); err == nil {
+			node, _ := strconv.Atoi(strings.TrimSpace(string(data)))
+			if node >= 0 {
+				topo.NICNUMAMap[name] = node
+			}
+		}
+	}
+}
+
+// findCrossNUMAPairs identifies GPU-NIC pairs on different NUMA nodes.
+func (c *GPUCollector) findCrossNUMAPairs(topo *model.PCIeTopology) {
+	for _, gpu := range topo.GPUs {
+		for nic, nicNode := range topo.NICNUMAMap {
+			if gpu.NUMANode != nicNode && gpu.NUMANode >= 0 && nicNode >= 0 {
+				topo.CrossNUMAPairs = append(topo.CrossNUMAPairs, model.CrossNUMAPair{
+					GPU:     gpu.Name,
+					GPUNode: gpu.NUMANode,
+					NIC:     nic,
+					NICNode: nicNode,
+				})
+			}
+		}
+	}
+}
+
+// pciNUMANode reads the NUMA node for a PCI device from sysfs.
+// PCIBus format from nvidia-smi: "00000000:01:00.0"
+func (c *GPUCollector) pciNUMANode(pciBus string) int {
+	// Try direct sysfs path
+	numaFile := filepath.Join(c.sysRoot, "bus", "pci", "devices", pciBus, "numa_node")
+	if data, err := os.ReadFile(numaFile); err == nil {
+		node, _ := strconv.Atoi(strings.TrimSpace(string(data)))
+		return node
+	}
+	return -1
+}

internal/collector/memory.go

@@ -37,8 +37,20 @@ func (c *MemoryCollector) Collect(ctx context.Context, cfg CollectConfig) (*mode
 	// /proc/meminfo
 	c.parseMeminfo(data)
 
-	// /proc/vmstat — page faults
+	// /proc/vmstat — page faults, reclaim, compaction, THP (two-point sampling)
+	vmstat1 := c.parseVmstatRaw()
+	interval := cfg.SampleInterval
+	if interval == 0 {
+		interval = 1 * time.Second
+	}
+	select {
+	case <-time.After(interval):
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	}
 	c.parseVmstat(data)
+	vmstat2 := c.parseVmstatRaw()
+	c.computeReclaimRates(data, vmstat1, vmstat2, interval.Seconds())
 
 	// vm.* sysctl settings
 	data.Swappiness = readSysctlInt(c.procRoot, "sys/vm/swappiness")
@@ -52,14 +64,22 @@ func (c *MemoryCollector) Collect(ctx context.Context, cfg CollectConfig) (*mode
 
 	// Transparent Huge Pages
 	data.THPEnabled = c.readTHPEnabled()
+	data.THPDefrag = c.readTHPDefrag()
+
+	// Additional vm.* sysctls
+	data.WatermarkScaleFactor = readSysctlInt(c.procRoot, "sys/vm/watermark_scale_factor")
+	data.DirtyExpireCentisecs = readSysctlInt(c.procRoot, "sys/vm/dirty_expire_centisecs")
+	data.DirtyWritebackCentisecs = readSysctlInt(c.procRoot, "sys/vm/dirty_writeback_centisecs")
+	data.ZoneReclaimMode = readSysctlInt(c.procRoot, "sys/vm/zone_reclaim_mode")
+	data.SchedNumaBalancing = readSysctlInt(c.procRoot, "sys/kernel/sched_numa_balancing")
 
 	// PSI memory pressure
 	c.parsePSI(data)
 
 	// /proc/buddyinfo
 	data.BuddyInfo = c.parseBuddyinfo()
 
-	// NUMA stats
+	// NUMA stats (with distance matrix and CPU list)
 	data.NUMANodes = c.parseNUMAStats()
 
 	return &model.Result{
@@ -124,6 +144,7 @@ func (c *MemoryCollector) parseVmstat(data *model.MemoryData) {
 	}
 	defer f.Close()
 
+	r := &model.ReclaimStats{}
 	scanner := bufio.NewScanner(f)
 	for scanner.Scan() {
 		fields := strings.Fields(scanner.Text())
@@ -136,8 +157,74 @@ func (c *MemoryCollector) parseVmstat(data *model.MemoryData) {
 			data.MajorFaults = val
 		case "pgfault":
 			data.MinorFaults = val
+		case "pgscan_direct":
+			r.PgscanDirect = val
+		case "pgscan_kswapd":
+			r.PgscanKswapd = val
+		case "pgsteal_direct":
+			r.PgstealDirect = val
+		case "pgsteal_kswapd":
+			r.PgstealKswapd = val
+		case "allocstall_normal":
+			r.AllocstallNormal = val
+		case "allocstall_dma":
+			r.AllocstallDMA = val
+		case "allocstall_movable":
+			r.AllocstallMovable = val
+		case "compact_stall":
+			r.CompactStall = val
+		case "compact_success":
+			r.CompactSuccess = val
+		case "compact_fail":
+			r.CompactFail = val
+		case "thp_fault_alloc":
+			r.THPFaultAlloc = val
+		case "thp_collapse_alloc":
+			r.THPCollapseAlloc = val
+		case "thp_split_page":
+			r.THPSplitPage = val
+		}
+	}
+	data.Reclaim = r
+}
+
+// parseVmstatRaw returns key vmstat counters as a map for rate computation.
+func (c *MemoryCollector) parseVmstatRaw() map[string]int64 {
+	f, err := os.Open(filepath.Join(c.procRoot, "vmstat"))
+	if err != nil {
+		return nil
+	}
+	defer f.Close()
+
+	m := make(map[string]int64)
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		fields := strings.Fields(scanner.Text())
+		if len(fields) != 2 {
+			continue
+		}
+		switch fields[0] {
+		case "pgscan_direct", "compact_stall", "thp_split_page", "allocstall_normal":
+			m[fields[0]], _ = strconv.ParseInt(fields[1], 10, 64)
 		}
 	}
+	return m
+}
+
+// computeReclaimRates computes per-second rates for reclaim counters.
+func (c *MemoryCollector) computeReclaimRates(data *model.MemoryData, v1, v2 map[string]int64, secs float64) {
+	if data == nil || data.Reclaim == nil || v1 == nil || v2 == nil || secs <= 0 {
+		return
+	}
+	if d := v2["pgscan_direct"] - v1["pgscan_direct"]; d > 0 {
+		data.Reclaim.DirectReclaimRate = float64(d) / secs
+	}
+	if d := v2["compact_stall"] - v1["compact_stall"]; d > 0 {
+		data.Reclaim.CompactStallRate = float64(d) / secs
+	}
+	if d := v2["thp_split_page"] - v1["thp_split_page"]; d > 0 {
+		data.Reclaim.THPSplitRate = float64(d) / secs
+	}
 }
 
 func (c *MemoryCollector) parsePSI(data *model.MemoryData) {
@@ -193,6 +280,21 @@ func (c *MemoryCollector) readTHPEnabled() string {
 	return strings.TrimSpace(content)
 }
 
+func (c *MemoryCollector) readTHPDefrag() string {
+	data, err := os.ReadFile(filepath.Join(c.sysRoot, "kernel", "mm", "transparent_hugepage", "defrag"))
+	if err != nil {
+		return ""
+	}
+	content := string(data)
+	if idx := strings.Index(content, "["); idx >= 0 {
+		end := strings.Index(content[idx:], "]")
+		if end > 0 {
+			return content[idx+1 : idx+end]
+		}
+	}
+	return strings.TrimSpace(content)
+}
+
 func (c *MemoryCollector) parseBuddyinfo() map[string][]int {
 	f, err := os.Open(filepath.Join(c.procRoot, "buddyinfo"))
 	if err != nil {
@@ -289,6 +391,25 @@ func (c *MemoryCollector) parseNUMAStats() []model.NUMANode {
 			f.Close()
 		}
 
+		// Compute miss ratio
+		total := node.NumaHit + node.NumaMiss
+		if total > 0 {
+			node.MissRatio = float64(node.NumaMiss) / float64(total) * 100
+		}
+
+		// Distance matrix
+		if distData, err := os.ReadFile(filepath.Join(nodePath, "distance")); err == nil {
+			for _, s := range strings.Fields(strings.TrimSpace(string(distData))) {
+				v, _ := strconv.Atoi(s)
+				node.Distance = append(node.Distance, v)
+			}
+		}
+
+		// CPU list
+		if cpuData, err := os.ReadFile(filepath.Join(nodePath, "cpulist")); err == nil {
+			node.CPUs = strings.TrimSpace(string(cpuData))
+		}
+
 		nodes = append(nodes, node)
 	}
 	return nodes