fix: refactor code to fit new topology provider format

JustinChengLZ · JustinChengLZ · commit 38c81a8c2368 · 2026-04-02T17:07:16.000+08:00
diff --git a/pkg/agent/qrm-plugins/gpu/baseplugin/reporter/reporter.go b/pkg/agent/qrm-plugins/gpu/baseplugin/reporter/reporter.go
@@ -311,7 +311,7 @@ func (p *gpuReporterPlugin) getResourcePropertyReportField(latestDeviceTopology
 // getGPUResourceProperty returns the different dimensions to differentiate affinity priority of gpu devices.
 func (p *gpuReporterPlugin) getGPUResourceProperty(deviceTopology *machine.DeviceTopology) []*nodev1alpha1.Property {
 	if deviceTopology == nil || len(deviceTopology.PriorityDimensions) == 0 {
-		return []*nodev1alpha1.Property{}
+		return nil
 	}
 
 	return []*nodev1alpha1.Property{
diff --git a/pkg/agent/qrm-plugins/gpu/customdeviceplugin/gpu/gpu.go b/pkg/agent/qrm-plugins/gpu/customdeviceplugin/gpu/gpu.go
@@ -52,8 +52,8 @@ func NewGPUDevicePlugin(base *baseplugin.BasePlugin) customdeviceplugin.CustomDe
 		base.DeviceTopologyRegistry.RegisterDeviceTopologyProvider(deviceName, gpuTopologyProvider)
 	}
 
-	// GPUDeviceType is the key used for state management in the QRM framework,
-	// while GPUDeviceNames are the actual resource names used to fetch the device topologies.
+	// GPUDeviceType is the key used for GPU state management in the QRM framework,
+	// while GPUDeviceNames are the actual resource names used to fetch the GPU device topologies.
 	base.DefaultResourceStateGeneratorRegistry.RegisterResourceStateGenerator(gpuconsts.GPUDeviceType,
 		state.NewGenericDefaultResourceStateGenerator(base.Conf.GPUDeviceNames, base.DeviceTopologyRegistry, 1))
 	base.RegisterDeviceNames(base.Conf.GPUDeviceNames, gpuconsts.GPUDeviceType)
@@ -137,13 +137,6 @@ func (p *GPUDevicePlugin) AllocateAssociatedDevice(
 			"podName", resReq.PodName,
 			"containerName", resReq.ContainerName)
 
-		// Get GPU topology using the specific device resource name
-		gpuTopology, err := p.DeviceTopologyRegistry.GetDeviceTopology(deviceReq.DeviceName)
-		if err != nil {
-			general.Warningf("failed to get gpu topology: %v", err)
-			return nil, fmt.Errorf("failed to get gpu topology: %w", err)
-		}
-
 		// Use the strategy framework to allocate GPU devices
 		result, err := manager.AllocateDevicesUsingStrategy(
 			resReq,
@@ -154,7 +147,7 @@ func (p *GPUDevicePlugin) AllocateAssociatedDevice(
 			p.MetaServer,
 			p.GetState().GetMachineState(),
 			qosLevel,
-			"",
+			deviceReq.DeviceName,
 			"",
 		)
 		if err != nil {
diff --git a/pkg/agent/qrm-plugins/gpu/customdeviceplugin/rdma/rdma.go b/pkg/agent/qrm-plugins/gpu/customdeviceplugin/rdma/rdma.go
@@ -41,10 +41,15 @@ type RDMADevicePlugin struct {
 }
 
 func NewRDMADevicePlugin(base *baseplugin.BasePlugin) customdeviceplugin.CustomDevicePlugin {
-	rdmaTopologyProvider := machine.NewDeviceTopologyProvider(base.Conf.RDMADeviceNames)
-	base.DeviceTopologyRegistry.RegisterDeviceTopologyProvider(gpuconsts.RDMADeviceType, rdmaTopologyProvider)
+	for _, deviceName := range base.Conf.RDMADeviceNames {
+		rdmaTopologyProvider := machine.NewDeviceTopologyProvider()
+		base.DeviceTopologyRegistry.RegisterDeviceTopologyProvider(deviceName, rdmaTopologyProvider)
+	}
+
+	// RDMADeviceType is the key used for RDMA state management in the QRM framework,
+	// while RDMADeviceNames are the actual resource names used to fetch the RDMA device topologies
 	base.DefaultResourceStateGeneratorRegistry.RegisterResourceStateGenerator(gpuconsts.RDMADeviceType,
-		state.NewGenericDefaultResourceStateGenerator(gpuconsts.RDMADeviceType, base.DeviceTopologyRegistry))
+		state.NewGenericDefaultResourceStateGenerator(base.Conf.RDMADeviceNames, base.DeviceTopologyRegistry))
 	base.RegisterDeviceNameToType(base.Conf.RDMADeviceNames, gpuconsts.RDMADeviceType)
 
 	return &RDMADevicePlugin{
@@ -62,7 +67,7 @@ func (p *RDMADevicePlugin) DeviceNames() []string {
 }
 
 func (p *RDMADevicePlugin) UpdateAllocatableAssociatedDevices(ctx context.Context, request *pluginapi.UpdateAllocatableAssociatedDevicesRequest) (*pluginapi.UpdateAllocatableAssociatedDevicesResponse, error) {
-	return p.UpdateAllocatableAssociatedDevicesByDeviceType(request, gpuconsts.RDMADeviceType)
+	return p.BasePlugin.UpdateAllocatableAssociatedDevices(request)
 }
 
 func (p *RDMADevicePlugin) GetAssociatedDeviceTopologyHints(context.Context, *pluginapi.AssociatedDeviceRequest) (*pluginapi.AssociatedDeviceHintsResponse, error) {
@@ -110,7 +115,8 @@ func (p *RDMADevicePlugin) AllocateAssociatedDevice(
 		}, nil
 	}
 
-	rdmaTopology, _, err := p.DeviceTopologyRegistry.GetDeviceTopology(gpuconsts.RDMADeviceType)
+	rdmaDeviceName := deviceReq.DeviceName
+	rdmaTopology, err := p.DeviceTopologyRegistry.GetDeviceTopology(rdmaDeviceName)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get gpu device topology: %v", err)
 	}
@@ -121,8 +127,6 @@ func (p *RDMADevicePlugin) AllocateAssociatedDevice(
 		return nil, err
 	}
 
-	accompanyResourceName = p.ResolveResourceName(accompanyResourceName, false)
-
 	// Use strategy framework to allocate RDMA devices
 	result, err := manager.AllocateDevicesUsingStrategy(
 		resReq,
@@ -133,7 +137,7 @@ func (p *RDMADevicePlugin) AllocateAssociatedDevice(
 		p.MetaServer,
 		p.GetState().GetMachineState(),
 		qosLevel,
-		gpuconsts.RDMADeviceType,
+		rdmaDeviceName,
 		accompanyResourceName,
 	)
 	if err != nil {
diff --git a/pkg/agent/qrm-plugins/gpu/customdeviceplugin/rdma/rdma_test.go b/pkg/agent/qrm-plugins/gpu/customdeviceplugin/rdma/rdma_test.go
@@ -112,8 +112,10 @@ func makeTestBasePlugin(t *testing.T) *baseplugin.BasePlugin {
 
 	// Register gpu device type and gpu device topology provider as it is an accompany resource for rdma
 	basePlugin.RegisterDeviceNameToType([]string{"test-gpu"}, gpuconsts.GPUDeviceType)
-	gpuTopologyProvider := machine.NewDeviceTopologyProvider([]string{"test-gpu"})
+	gpuTopologyProvider := machine.NewDeviceTopologyProvider()
 	basePlugin.DeviceTopologyRegistry.RegisterDeviceTopologyProvider(gpuconsts.GPUDeviceType, gpuTopologyProvider)
+	// Also register a provider for rdma device type to align with plugin lookup by type
+	basePlugin.DeviceTopologyRegistry.RegisterDeviceTopologyProvider(gpuconsts.RDMADeviceType, machine.NewDeviceTopologyProvider())
 
 	return basePlugin
 }
@@ -157,9 +159,8 @@ func TestRDMADevicePlugin_UpdateAllocatableAssociatedDevices(t *testing.T) {
 
 	// Verify device topology is updated
 	gpuDevicePlugin := devicePlugin.(*RDMADevicePlugin)
-	deviceTopology, numaTopologyReady, err := gpuDevicePlugin.DeviceTopologyRegistry.GetDeviceTopology(gpuconsts.RDMADeviceType)
+	deviceTopology, err := gpuDevicePlugin.DeviceTopologyRegistry.GetDeviceTopology(basePlugin.Conf.RDMADeviceNames[0])
 	assert.NoError(t, err)
-	assert.True(t, numaTopologyReady)
 	assert.NotNil(t, deviceTopology)
 
 	expectedDeviceTopology := &machine.DeviceTopology{
@@ -175,7 +176,8 @@ func TestRDMADevicePlugin_UpdateAllocatableAssociatedDevices(t *testing.T) {
 		},
 	}
 
-	assert.Equal(t, expectedDeviceTopology, deviceTopology)
+	// Compare device contents; ignore dynamic UpdateTime field
+	assert.Equal(t, expectedDeviceTopology.Devices, deviceTopology.Devices)
 }
 
 func TestRDMADevicePlugin_AllocateAssociatedDevices(t *testing.T) {
@@ -470,8 +472,11 @@ func TestRDMADevicePlugin_AllocateAssociatedDevices(t *testing.T) {
 			}
 
 			if tt.deviceTopology != nil {
+				// Set topology under both type and specific device name to satisfy plugin + generator lookups
 				err := basePlugin.DeviceTopologyRegistry.SetDeviceTopology(gpuconsts.RDMADeviceType, tt.deviceTopology)
 				assert.NoError(t, err)
+				err = basePlugin.DeviceTopologyRegistry.SetDeviceTopology(basePlugin.Conf.RDMADeviceNames[0], tt.deviceTopology)
+				assert.NoError(t, err)
 			}
 
 			if tt.accompanyResourceName != "" && tt.accompanyDeviceTopology != nil {
diff --git a/pkg/agent/qrm-plugins/gpu/resourceplugin/gpumemory/gpu_mem.go b/pkg/agent/qrm-plugins/gpu/resourceplugin/gpumemory/gpu_mem.go
@@ -533,7 +533,7 @@ func (p *GPUMemPlugin) Allocate(
 		p.MetaServer,
 		p.GetState().GetMachineState(),
 		qosLevel,
-		"",
+		deviceReq.DeviceName,
 		"",
 	)
 	if err != nil {
diff --git a/pkg/agent/qrm-plugins/gpu/staticpolicy/policy_test.go b/pkg/agent/qrm-plugins/gpu/staticpolicy/policy_test.go
@@ -45,14 +45,19 @@ const (
 	testResourcePluginName      = "resource-plugin-stub"
 	testCustomDevicePluginName  = "custom-device-plugin-stub"
 	testCustomDevicePluginName2 = "custom-device-plugin-stub-2"
+	// RDMA device name used for tests so that RDMA default state generation succeeds
+	testRDMADeviceName = "rdma-stub"
 )
 
 func generateTestConfiguration(t *testing.T) *config.Configuration {
 	conf := config.NewConfiguration()
 	tmpDir := t.TempDir()
 	conf.QRMPluginSocketDirs = []string{tmpDir}
 	conf.CheckpointManagerDir = tmpDir
-	conf.GPUDeviceNames = []string{testResourcePluginName} // Add default device name for tests
+	// Add default device names for tests
+	conf.GPUDeviceNames = []string{testResourcePluginName}
+	// Ensure RDMA generator has a device name to reference during InitState
+	conf.RDMADeviceNames = []string{testRDMADeviceName}
 
 	return conf
 }
@@ -158,6 +163,15 @@ func makeTestStaticPolicy(t *testing.T) *StaticPolicy {
 	err = staticPolicy.DeviceTopologyRegistry.SetDeviceTopology(testResourcePluginName, testDeviceTopology)
 	assert.NoError(t, err)
 
+	// Also set a minimal RDMA device topology to satisfy RDMA default state generation during InitState
+	rdmaDeviceTopology := &machine.DeviceTopology{
+		Devices: map[string]machine.DeviceInfo{
+			"rdma-1": {},
+		},
+	}
+	err = staticPolicy.DeviceTopologyRegistry.SetDeviceTopology(testRDMADeviceName, rdmaDeviceTopology)
+	assert.NoError(t, err)
+
 	return staticPolicy
 }
 
diff --git a/pkg/agent/qrm-plugins/gpu/strategy/allocate/manager/helper.go b/pkg/agent/qrm-plugins/gpu/strategy/allocate/manager/helper.go
@@ -21,7 +21,6 @@ import (
 
 	pluginapi "k8s.io/kubelet/pkg/apis/resourceplugin/v1alpha1"
 
-	"github.com/kubewharf/katalyst-core/pkg/agent/qrm-plugins/gpu/consts"
 	"github.com/kubewharf/katalyst-core/pkg/agent/qrm-plugins/gpu/state"
 	"github.com/kubewharf/katalyst-core/pkg/agent/qrm-plugins/gpu/strategy/allocate"
 	"github.com/kubewharf/katalyst-core/pkg/config/agent/qrm"
@@ -50,10 +49,6 @@ func AllocateDevicesUsingStrategy(
 		}, err
 	}
 
-	if resourceName == "" {
-		resourceName = consts.GPUDeviceType
-	}
-
 	// Create allocation context
 	ctx := &allocate.AllocationContext{
 		ResourceReq:            resourceReq,
diff --git a/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies/accompanyresource/bind.go b/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies/accompanyresource/bind.go
@@ -21,13 +21,13 @@ import (
 	"math"
 	"sort"
 
-	"github.com/kubewharf/katalyst-core/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies"
-	"github.com/kubewharf/katalyst-core/pkg/util/machine"
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/util/sets"
 
 	"github.com/kubewharf/katalyst-core/pkg/agent/qrm-plugins/gpu/strategy/allocate"
+	"github.com/kubewharf/katalyst-core/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies"
 	"github.com/kubewharf/katalyst-core/pkg/util/general"
+	"github.com/kubewharf/katalyst-core/pkg/util/machine"
 )
 
 // Bind tries to allocate devices by maximizing affinity with the accompany resource devices, making sure that it is
diff --git a/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies/accompanyresource/bind_test.go b/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies/accompanyresource/bind_test.go
@@ -574,8 +574,8 @@ func buildSimpleAffinityRegistry(rdmaToGPU map[string][]string) *machine.DeviceT
 	reg := machine.NewDeviceTopologyRegistry()
 
 	// Register topology providers for both devices
-	reg.RegisterDeviceTopologyProvider("rdma", machine.NewDeviceTopologyProvider([]string{"rdma"}))
-	reg.RegisterDeviceTopologyProvider("gpu", machine.NewDeviceTopologyProvider([]string{"gpu"}))
+	reg.RegisterDeviceTopologyProvider("rdma", machine.NewDeviceTopologyProvider())
+	reg.RegisterDeviceTopologyProvider("gpu", machine.NewDeviceTopologyProvider())
 
 	// Construct RDMA topology
 	rdmaTopo := &machine.DeviceTopology{Devices: map[string]machine.DeviceInfo{}}
@@ -614,8 +614,8 @@ func buildSimpleAffinityRegistry(rdmaToGPU map[string][]string) *machine.DeviceT
 func buildMultiPriorityAffinityRegistry(cfg map[string]map[int][]string) *machine.DeviceTopologyRegistry {
 	reg := machine.NewDeviceTopologyRegistry()
 
-	reg.RegisterDeviceTopologyProvider("rdma", machine.NewDeviceTopologyProvider([]string{"rdma"}))
-	reg.RegisterDeviceTopologyProvider("gpu", machine.NewDeviceTopologyProvider([]string{"gpu"}))
+	reg.RegisterDeviceTopologyProvider("rdma", machine.NewDeviceTopologyProvider())
+	reg.RegisterDeviceTopologyProvider("gpu", machine.NewDeviceTopologyProvider())
 
 	rdmaTopo := &machine.DeviceTopology{Devices: map[string]machine.DeviceInfo{}}
 	for rdmaID, prios := range cfg {
@@ -652,8 +652,8 @@ func buildMultiPriorityAffinityRegistry(cfg map[string]map[int][]string) *machin
 func buildNoAffinityRegistry() *machine.DeviceTopologyRegistry {
 	reg := machine.NewDeviceTopologyRegistry()
 
-	reg.RegisterDeviceTopologyProvider("rdma", machine.NewDeviceTopologyProvider([]string{"rdma"}))
-	reg.RegisterDeviceTopologyProvider("gpu", machine.NewDeviceTopologyProvider([]string{"gpu"}))
+	reg.RegisterDeviceTopologyProvider("rdma", machine.NewDeviceTopologyProvider())
+	reg.RegisterDeviceTopologyProvider("gpu", machine.NewDeviceTopologyProvider())
 
 	// RDMA devices use dimension "rdma_link"
 	rdmaTopo := &machine.DeviceTopology{Devices: map[string]machine.DeviceInfo{}}
diff --git a/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies/canonical/bind_test.go b/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies/canonical/bind_test.go
@@ -135,7 +135,7 @@ func TestCanonicalStrategy_Bind(t *testing.T) {
 			// Prepare topology registry if provided
 			if tt.topology != nil {
 				reg := machine.NewDeviceTopologyRegistry()
-				reg.RegisterDeviceTopologyProvider(consts.GPUDeviceType, machine.NewDeviceTopologyProvider([]string{"gpu"}))
+				reg.RegisterDeviceTopologyProvider(consts.GPUDeviceType, machine.NewDeviceTopologyProvider())
 				_ = reg.SetDeviceTopology(consts.GPUDeviceType, tt.topology)
 				tt.ctx.DeviceTopologyRegistry = reg
 			}
diff --git a/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies/canonical/filter.go b/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies/canonical/filter.go
@@ -36,7 +36,7 @@ func (s *CanonicalStrategy) Filter(
 	}
 
 	filteredDevices := sets.NewString()
-	gpuTopo, _, err := ctx.DeviceTopologyRegistry.GetDeviceTopology(ctx.ResourceName)
+	gpuTopo, err := ctx.DeviceTopologyRegistry.GetDeviceTopology(ctx.ResourceName)
 	if err != nil {
 		return nil, fmt.Errorf("canonical strategy failed to get gpu topology: %w", err)
 	}
diff --git a/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies/canonical/filter_test.go b/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies/canonical/filter_test.go
@@ -69,7 +69,7 @@ func TestCanonicalStrategy_Filter(t *testing.T) {
 
 			if tt.topology != nil {
 				reg := machine.NewDeviceTopologyRegistry()
-				reg.RegisterDeviceTopologyProvider(consts.GPUDeviceType, machine.NewDeviceTopologyProvider([]string{"gpu"}))
+				reg.RegisterDeviceTopologyProvider(consts.GPUDeviceType, machine.NewDeviceTopologyProvider())
 				_ = reg.SetDeviceTopology(consts.GPUDeviceType, tt.topology)
 				tt.ctx.DeviceTopologyRegistry = reg
 				tt.ctx.ResourceName = consts.GPUDeviceType
diff --git a/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies/deviceaffinity/bind.go b/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies/deviceaffinity/bind.go
@@ -23,7 +23,6 @@ import (
 	"github.com/google/uuid"
 	"k8s.io/apimachinery/pkg/util/sets"
 
-	gpuconsts "github.com/kubewharf/katalyst-core/pkg/agent/qrm-plugins/gpu/consts"
 	"github.com/kubewharf/katalyst-core/pkg/agent/qrm-plugins/gpu/strategy/allocate"
 	"github.com/kubewharf/katalyst-core/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies"
 	"github.com/kubewharf/katalyst-core/pkg/metrics"
@@ -65,7 +64,7 @@ func (s *DeviceAffinityStrategy) Bind(
 	unallocatedDevicesSet := sets.NewString(sortedDevices...)
 
 	// Get GPU topology
-	gpuTopology, _, err := ctx.DeviceTopologyRegistry.GetDeviceTopology(gpuconsts.GPUDeviceType)
+	gpuTopology, err := ctx.DeviceTopologyRegistry.GetDeviceTopology(ctx.ResourceName)
 	if err != nil {
 		general.Warningf("failed to get gpu topology: %v", err)
 		return nil, fmt.Errorf("failed to get gpu topology: %w", err)
diff --git a/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies/deviceaffinity/bind_test.go b/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies/deviceaffinity/bind_test.go
@@ -2243,13 +2243,13 @@ func TestBind_NumberOfDevicesAllocated(t *testing.T) {
 					ReusableDevices: nil,
 					DeviceRequest:   2,
 				},
-				DeviceTopology: &machine.DeviceTopology{
-					Devices: map[string]machine.DeviceInfo{
-						"gpu-1": {},
-						"gpu-2": {},
-						"gpu-3": {},
-						"gpu-4": {},
-					},
+			},
+			topology: &machine.DeviceTopology{
+				Devices: map[string]machine.DeviceInfo{
+					"gpu-1": {},
+					"gpu-2": {},
+					"gpu-3": {},
+					"gpu-4": {},
 				},
 			},
 			sortedDevices: []string{"gpu-1", "gpu-2", "gpu-3", "gpu-4"},
@@ -2270,13 +2270,13 @@ func TestBind_NumberOfDevicesAllocated(t *testing.T) {
 					ReusableDevices: []string{"gpu-1", "gpu-2"},
 					DeviceRequest:   2,
 				},
-				DeviceTopology: &machine.DeviceTopology{
-					Devices: map[string]machine.DeviceInfo{
-						"gpu-1": {},
-						"gpu-2": {},
-						"gpu-3": {},
-						"gpu-4": {},
-					},
+			},
+			topology: &machine.DeviceTopology{
+				Devices: map[string]machine.DeviceInfo{
+					"gpu-1": {},
+					"gpu-2": {},
+					"gpu-3": {},
+					"gpu-4": {},
 				},
 			},
 			sortedDevices: []string{"gpu-1", "gpu-2", "gpu-3", "gpu-4"},
@@ -2294,12 +2294,14 @@ func TestBind_NumberOfDevicesAllocated(t *testing.T) {
 			// Setup topology registry when a topology is provided
 			if tt.topology != nil {
 				reg := machine.NewDeviceTopologyRegistry()
-				reg.RegisterDeviceTopologyProvider(consts.GPUDeviceType, machine.NewDeviceTopologyProvider([]string{"gpu"}))
+				reg.RegisterDeviceTopologyProvider(consts.GPUDeviceType, machine.NewDeviceTopologyProvider())
 				_ = reg.SetDeviceTopology(consts.GPUDeviceType, tt.topology)
 				if tt.ctx == nil {
 					tt.ctx = &allocate.AllocationContext{}
 				}
 				tt.ctx.DeviceTopologyRegistry = reg
+				// Ensure ResourceName matches the registered provider device type
+				tt.ctx.ResourceName = consts.GPUDeviceType
 			}
 			deviceBindingStrategy := NewDeviceAffinityStrategy()
 			tt.ctx.Emitter = metrics.DummyMetrics{}
@@ -2691,12 +2693,14 @@ func TestBind_DeviceAffinity(t *testing.T) {
 			t.Parallel()
 			if tt.topology != nil {
 				reg := machine.NewDeviceTopologyRegistry()
-				reg.RegisterDeviceTopologyProvider(consts.GPUDeviceType, machine.NewDeviceTopologyProvider([]string{"gpu"}))
+				reg.RegisterDeviceTopologyProvider(consts.GPUDeviceType, machine.NewDeviceTopologyProvider())
 				_ = reg.SetDeviceTopology(consts.GPUDeviceType, tt.topology)
 				if tt.ctx == nil {
 					tt.ctx = &allocate.AllocationContext{}
 				}
 				tt.ctx.DeviceTopologyRegistry = reg
+				// Ensure ResourceName matches the registered provider device type
+				tt.ctx.ResourceName = consts.GPUDeviceType
 			}
 			deviceBindingStrategy := NewDeviceAffinityStrategy()
 			tt.ctx.Emitter = metrics.DummyMetrics{}
diff --git a/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies/gpu_memory/sort.go b/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies/gpu_memory/sort.go
@@ -57,7 +57,7 @@ func (s *GPUMemoryStrategy) Sort(ctx *allocate.AllocationContext, filteredDevice
 
 	devices := make([]deviceInfo, 0, len(filteredDevices))
 
-	topology, _, err := ctx.DeviceTopologyRegistry.GetDeviceTopology(ctx.ResourceName)
+	topology, err := ctx.DeviceTopologyRegistry.GetDeviceTopology(ctx.ResourceName)
 	if err != nil {
 		return nil, fmt.Errorf("GPU memory strategy failed to get gpu topology: %w", err)
 	}
diff --git a/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies/gpu_memory/sort_test.go b/pkg/agent/qrm-plugins/gpu/strategy/allocate/strategies/gpu_memory/sort_test.go
@@ -141,7 +141,7 @@ func TestGPUMemoryStrategy_Sort(t *testing.T) {
 			t.Parallel()
 			if tt.topology != nil {
 				reg := machine.NewDeviceTopologyRegistry()
-				reg.RegisterDeviceTopologyProvider(gpuconsts.GPUDeviceType, machine.NewDeviceTopologyProvider([]string{"gpu"}))
+				reg.RegisterDeviceTopologyProvider(gpuconsts.GPUDeviceType, machine.NewDeviceTopologyProvider())
 				_ = reg.SetDeviceTopology(gpuconsts.GPUDeviceType, tt.topology)
 				tt.ctx.DeviceTopologyRegistry = reg
 				tt.ctx.ResourceName = gpuconsts.GPUDeviceType
diff --git a/pkg/util/machine/device.go b/pkg/util/machine/device.go

Original file line number	Diff line number	Diff line change
`@@ -311,7 +311,7 @@ func (p *gpuReporterPlugin) getResourcePropertyReportField(latestDeviceTopology`
`311`	`311`	`// getGPUResourceProperty returns the different dimensions to differentiate affinity priority of gpu devices.`
`312`	`312`	`func (p gpuReporterPlugin) getGPUResourceProperty(deviceTopology machine.DeviceTopology) []*nodev1alpha1.Property {`
`313`	`313`	`if deviceTopology == nil \|\| len(deviceTopology.PriorityDimensions) == 0 {`
`314`		`- return []*nodev1alpha1.Property{}`
	`314`	`+ return nil`
`315`	`315`	`}`
`316`	`316`
`317`	`317`	`return []*nodev1alpha1.Property{`
Original file line number	Diff line number	Diff line change
`@@ -533,7 +533,7 @@ func (p *GPUMemPlugin) Allocate(`
`533`	`533`	`p.MetaServer,`
`534`	`534`	`p.GetState().GetMachineState(),`
`535`	`535`	`qosLevel,`
`536`		`- "",`
	`536`	`+ deviceReq.DeviceName,`
`537`	`537`	`"",`
`538`	`538`	`)`
`539`	`539`	`if err != nil {`
Original file line number	Diff line number	Diff line change
`@@ -135,7 +135,7 @@ func TestCanonicalStrategy_Bind(t *testing.T) {`
`135`	`135`	`// Prepare topology registry if provided`
`136`	`136`	`if tt.topology != nil {`
`137`	`137`	`reg := machine.NewDeviceTopologyRegistry()`
`138`		`- reg.RegisterDeviceTopologyProvider(consts.GPUDeviceType, machine.NewDeviceTopologyProvider([]string{"gpu"}))`
	`138`	`+ reg.RegisterDeviceTopologyProvider(consts.GPUDeviceType, machine.NewDeviceTopologyProvider())`
`139`	`139`	`_ = reg.SetDeviceTopology(consts.GPUDeviceType, tt.topology)`
`140`	`140`	`tt.ctx.DeviceTopologyRegistry = reg`
`141`	`141`	`}`