Add WithDisableTopology option to reduce memory consumption

This commit adds a new WithDisableTopology() option that allows users
to skip system topology detection when calling ghw.PCI() or ghw.GPU(),
significantly reducing memory consumption for use cases that don't
require NUMA topology information.

Author: halfcrazy

pkg/context/context.go

@@ -22,6 +22,7 @@ type Context struct {
 	SnapshotRoot         string
 	SnapshotExclusive    bool
 	PathOverrides        option.PathOverrides
+	DisableTopology      bool
 	snapshotUnpackedPath string
 	alert                option.Alerter
 	err                  error
@@ -83,6 +84,10 @@ func New(opts ...*option.Option) *Context {
 		ctx.PathOverrides = merged.PathOverrides
 	}
 
+	if merged.DisableTopology != nil {
+		ctx.DisableTopology = *merged.DisableTopology
+	}
+
 	// New is not allowed to return error - it would break the established API.
 	// so the only way out is to actually do the checks here and record the error,
 	// and return it later, at the earliest possible occasion, in Setup()

pkg/gpu/gpu_linux.go

@@ -134,6 +134,14 @@ func gpuFillPCIDevice(ctx *context.Context, cards []*GraphicsCard) {
 // affined to, setting the GraphicsCard.Node field accordingly. If the host
 // system is not a NUMA system, the Node field will be set to nil.
 func gpuFillNUMANodes(ctx *context.Context, cards []*GraphicsCard) {
+	// Skip topology detection if requested to reduce memory consumption
+	if ctx.DisableTopology {
+		for _, card := range cards {
+			card.Node = nil
+		}
+		return
+	}
+
 	paths := linuxpath.New(ctx)
 	topo, err := topology.New(context.WithContext(ctx))
 	if err != nil {

pkg/option/option.go

@@ -148,6 +148,13 @@ type Option struct {
 	// or providing an instance created with custom pcidb.WithOption settings, instead of
 	// letting ghw load the PCI database automatically.
 	PCIDB *pcidb.PCIDB
+
+	// DisableTopology skips system topology detection when calling PCI() or GPU().
+	// This can significantly reduce memory consumption when you only need basic
+	// hardware information and don't care about NUMA topology or node affinity.
+	// When enabled, the system architecture will be assumed to be SMP and device
+	// Node fields will be nil.
+	DisableTopology *bool
 }
 
 // SnapshotOptions contains options for handling of ghw snapshots
@@ -211,6 +218,16 @@ func WithPCIDB(pcidb *pcidb.PCIDB) *Option {
 	return &Option{PCIDB: pcidb}
 }
 
+// WithDisableTopology disables system topology detection to reduce memory consumption.
+// When using this option, ghw will skip scanning NUMA topology, CPU cores, memory
+// caches, and node distances. This is useful when you only need basic PCI or GPU
+// information and want to minimize memory overhead. The system architecture will be
+// assumed to be SMP, and device Node fields will be nil.
+func WithDisableTopology() *Option {
+	disabled := true
+	return &Option{DisableTopology: &disabled}
+}
+
 // PathOverrides is a map, keyed by the string name of a mount path, of override paths
 type PathOverrides map[string]string
 
@@ -252,6 +269,9 @@ func Merge(opts ...*Option) *Option {
 		if opt.PCIDB != nil {
 			merged.PCIDB = opt.PCIDB
 		}
+		if opt.DisableTopology != nil {
+			merged.DisableTopology = opt.DisableTopology
+		}
 	}
 	// Set the default value if missing from mergeOpts
 	if merged.Chroot == nil {

pkg/option/option_test.go

@@ -172,6 +172,27 @@ func TestOption(t *testing.T) {
 				},
 			},
 		},
+		{
+			name: "disable topology",
+			opts: []*option.Option{
+				option.WithDisableTopology(),
+			},
+			merged: &option.Option{
+				DisableTopology: boolPtr(true),
+			},
+		},
+		{
+			name: "chroot and disable topology",
+			opts: []*option.Option{
+				option.WithChroot("/my/chroot/dir"),
+				option.WithDisableTopology(),
+			},
+			merged: &option.Option{
+				Chroot:          stringPtr("/my/chroot/dir"),
+				DisableTopology: boolPtr(true),
+				EnableTools:     boolPtr(true),
+			},
+		},
 	}
 	if pciTest != nil {
 		optTCases = append(optTCases, *pciTest)
@@ -220,6 +241,14 @@ func optionEqual(a, b *option.Option) (string, bool) {
 			return "enabletools value", false
 		}
 	}
+	if a.DisableTopology != nil {
+		if b.DisableTopology == nil {
+			return "disabletopology ptr", false
+		}
+		if *a.DisableTopology != *b.DisableTopology {
+			return "disabletopology value", false
+		}
+	}
 	return "", true
 }
 

pkg/pci/pci.go

@@ -146,11 +146,16 @@ func New(opts ...*option.Option) (*Info, error) {
 	// a chance to run before any subordinate package is created reusing
 	// our context.
 	loadDetectingTopology := func() error {
-		topo, err := topology.New(context.WithContext(ctx))
-		if err == nil {
-			info.arch = topo.Architecture
+		// Skip topology detection if requested to reduce memory consumption
+		if merged.DisableTopology != nil && *merged.DisableTopology {
+			ctx.Warn("topology detection disabled, assuming SMP architecture")
 		} else {
-			ctx.Warn("error detecting system topology: %v", err)
+			topo, err := topology.New(context.WithContext(ctx))
+			if err == nil {
+				info.arch = topo.Architecture
+			} else {
+				ctx.Warn("error detecting system topology: %v", err)
+			}
 		}
 		if merged.PCIDB != nil {
 			info.db = merged.PCIDB

pkg/pci/pci_test.go

@@ -10,6 +10,7 @@ import (
 	"os"
 	"testing"
 
+	"github.com/jaypipes/ghw/pkg/option"
 	"github.com/jaypipes/ghw/pkg/pci"
 )
 
@@ -58,3 +59,67 @@ func TestPCI(t *testing.T) {
 		}
 	}
 }
+
+func TestPCIWithDisableTopology(t *testing.T) {
+	if _, ok := os.LookupEnv("GHW_TESTING_SKIP_PCI"); ok {
+		t.Skip("Skipping PCI tests.")
+	}
+
+	// Test with DisableTopology option enabled
+	info, err := pci.New(option.WithDisableTopology())
+	if err != nil {
+		t.Fatalf("Expected no error creating PciInfo with DisableTopology, but got %v", err)
+	}
+
+	devs := info.Devices
+	if len(devs) == 0 {
+		t.Fatalf("Expected to find >0 PCI devices in PCIInfo.Devices but got 0.")
+	}
+
+	// When DisableTopology is enabled, all devices should have nil Node field
+	for _, dev := range devs {
+		if dev.Node != nil {
+			t.Errorf("Expected device %s to have nil Node when DisableTopology is enabled, but got %v", dev.Address, dev.Node)
+		}
+		// Verify other fields are still populated correctly
+		if dev.Class == nil {
+			t.Fatalf("Expected device class for %s to be non-nil", dev.Address)
+		}
+		if dev.Product == nil {
+			t.Fatalf("Expected device product for %s to be non-nil", dev.Address)
+		}
+		if dev.Vendor == nil {
+			t.Fatalf("Expected device vendor for %s to be non-nil", dev.Address)
+		}
+	}
+}
+
+func BenchmarkPCIMemoryComparison(b *testing.B) {
+	if _, ok := os.LookupEnv("GHW_TESTING_SKIP_PCI"); ok {
+		b.Skip("Skipping PCI benchmarks.")
+	}
+
+	b.Run("WithTopologyDetection", func(b *testing.B) {
+		b.ReportAllocs()
+		b.ResetTimer()
+
+		for i := 0; i < b.N; i++ {
+			_, err := pci.New()
+			if err != nil {
+				b.Fatalf("Error getting PCI info: %v", err)
+			}
+		}
+	})
+
+	b.Run("WithDisableTopology", func(b *testing.B) {
+		b.ReportAllocs()
+		b.ResetTimer()
+
+		for i := 0; i < b.N; i++ {
+			_, err := pci.New(option.WithDisableTopology())
+			if err != nil {
+				b.Fatalf("Error getting PCI info with DisableTopology: %v", err)
+			}
+		}
+	})
+}