From df9b2595f38a95f5c009ea0f94a80b9b1d01c1fa Mon Sep 17 00:00:00 2001 From: nolancon Date: Wed, 22 Jan 2020 07:15:00 +0000 Subject: [PATCH 1/4] Update filterHints to filterSingleNumaHints: - Change function name - Remove policy parameter (unnecessary) - Update unit test to reflect change --- pkg/kubelet/cm/topologymanager/policy_single_numa_node.go | 4 ++-- .../cm/topologymanager/policy_single_numa_node_test.go | 4 +--- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/pkg/kubelet/cm/topologymanager/policy_single_numa_node.go b/pkg/kubelet/cm/topologymanager/policy_single_numa_node.go index ccbbe213aec..1aeaf23cfd4 100644 --- a/pkg/kubelet/cm/topologymanager/policy_single_numa_node.go +++ b/pkg/kubelet/cm/topologymanager/policy_single_numa_node.go @@ -55,7 +55,7 @@ func (p *singleNumaNodePolicy) canAdmitPodResult(hint *TopologyHint) lifecycle.P } // Return hints that have valid bitmasks with exactly one bit set. -func (p *singleNumaNodePolicy) filterHints(allResourcesHints [][]TopologyHint) [][]TopologyHint { +func filterSingleNumaHints(allResourcesHints [][]TopologyHint) [][]TopologyHint { var filteredResourcesHints [][]TopologyHint for _, oneResourceHints := range allResourcesHints { var filtered []TopologyHint @@ -108,7 +108,7 @@ func (p *singleNumaNodePolicy) mergeProvidersHints(providersHints []map[string][ } // Filter to only include don't cares and hints with a single NUMA node. - allProviderHints = p.filterHints(allProviderHints) + allProviderHints = filterSingleNumaHints(allProviderHints) // Set the bestHint to return from this function as {nil false}. // This will only be returned if no better hint can be found when diff --git a/pkg/kubelet/cm/topologymanager/policy_single_numa_node_test.go b/pkg/kubelet/cm/topologymanager/policy_single_numa_node_test.go index d8664e46b5c..d201adcafbd 100644 --- a/pkg/kubelet/cm/topologymanager/policy_single_numa_node_test.go +++ b/pkg/kubelet/cm/topologymanager/policy_single_numa_node_test.go @@ -155,10 +155,8 @@ func TestPolicySingleNumaNodeFilterHints(t *testing.T) { }, } - numaNodes := []int{0, 1, 2, 3} for _, tc := range tcases { - policy := NewSingleNumaNodePolicy(numaNodes) - actual := policy.(*singleNumaNodePolicy).filterHints(tc.allResources) + actual := filterSingleNumaHints(tc.allResources) if !reflect.DeepEqual(tc.expectedResources, actual) { t.Errorf("Test Case: %s", tc.name) t.Errorf("Expected result to be %v, got %v", tc.expectedResources, actual) From 45660fd3a2559a8a7f23f9a3ae2d7338f7091efc Mon Sep 17 00:00:00 2001 From: nolancon Date: Wed, 22 Jan 2020 08:19:57 +0000 Subject: [PATCH 2/4] Add filterProvidersHints function: - Move initial 'filtering' functionality to generic function filterProvidersHints level policy.go. - Call new function from top level Merge function. - Rename some variables/parameters to reflect changes. --- pkg/kubelet/cm/topologymanager/policy.go | 34 ++++++++++++++++ .../cm/topologymanager/policy_best_effort.go | 38 ++---------------- .../cm/topologymanager/policy_restricted.go | 3 +- .../policy_single_numa_node.go | 40 +++---------------- 4 files changed, 45 insertions(+), 70 deletions(-) diff --git a/pkg/kubelet/cm/topologymanager/policy.go b/pkg/kubelet/cm/topologymanager/policy.go index f2df6f29b27..b04062a8d64 100644 --- a/pkg/kubelet/cm/topologymanager/policy.go +++ b/pkg/kubelet/cm/topologymanager/policy.go @@ -17,6 +17,7 @@ limitations under the License. package topologymanager import ( + "k8s.io/klog" "k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/bitmask" "k8s.io/kubernetes/pkg/kubelet/lifecycle" ) @@ -59,6 +60,39 @@ func mergePermutation(numaNodes []int, permutation []TopologyHint) TopologyHint return TopologyHint{mergedAffinity, preferred} } +func filterProvidersHints(providersHints []map[string][]TopologyHint) [][]TopologyHint { + // Loop through all hint providers and save an accumulated list of the + // hints returned by each hint provider. If no hints are provided, assume + // that provider has no preference for topology-aware allocation. + var allProviderHints [][]TopologyHint + for _, hints := range providersHints { + // If hints is nil, insert a single, preferred any-numa hint into allProviderHints. + if len(hints) == 0 { + klog.Infof("[topologymanager] Hint Provider has no preference for NUMA affinity with any resource") + allProviderHints = append(allProviderHints, []TopologyHint{{nil, true}}) + continue + } + + // Otherwise, accumulate the hints for each resource type into allProviderHints. + for resource := range hints { + if hints[resource] == nil { + klog.Infof("[topologymanager] Hint Provider has no preference for NUMA affinity with resource '%s'", resource) + allProviderHints = append(allProviderHints, []TopologyHint{{nil, true}}) + continue + } + + if len(hints[resource]) == 0 { + klog.Infof("[topologymanager] Hint Provider has no possible NUMA affinities for resource '%s'", resource) + allProviderHints = append(allProviderHints, []TopologyHint{{nil, false}}) + continue + } + + allProviderHints = append(allProviderHints, hints[resource]) + } + } + return allProviderHints +} + // Iterate over all permutations of hints in 'allProviderHints [][]TopologyHint'. // // This procedure is implemented as a recursive function over the set of hints diff --git a/pkg/kubelet/cm/topologymanager/policy_best_effort.go b/pkg/kubelet/cm/topologymanager/policy_best_effort.go index fdcf3a55087..2bdf17ba995 100644 --- a/pkg/kubelet/cm/topologymanager/policy_best_effort.go +++ b/pkg/kubelet/cm/topologymanager/policy_best_effort.go @@ -17,7 +17,6 @@ limitations under the License. package topologymanager import ( - "k8s.io/klog" "k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/bitmask" "k8s.io/kubernetes/pkg/kubelet/lifecycle" ) @@ -48,54 +47,25 @@ func (p *bestEffortPolicy) canAdmitPodResult(hint *TopologyHint) lifecycle.PodAd } func (p *bestEffortPolicy) Merge(providersHints []map[string][]TopologyHint) (TopologyHint, lifecycle.PodAdmitResult) { - hint := p.mergeProvidersHints(providersHints) + filteredProvidersHints := filterProvidersHints(providersHints) + hint := p.mergeProvidersHints(filteredProvidersHints) admit := p.canAdmitPodResult(&hint) return hint, admit } // Merge the hints from all hint providers to find the best one. -func (p *bestEffortPolicy) mergeProvidersHints(providersHints []map[string][]TopologyHint) TopologyHint { +func (p *bestEffortPolicy) mergeProvidersHints(filteredHints [][]TopologyHint) TopologyHint { // Set the default affinity as an any-numa affinity containing the list // of NUMA Nodes available on this machine. defaultAffinity, _ := bitmask.NewBitMask(p.numaNodes...) - // Loop through all hint providers and save an accumulated list of the - // hints returned by each hint provider. If no hints are provided, assume - // that provider has no preference for topology-aware allocation. - var allProviderHints [][]TopologyHint - for _, hints := range providersHints { - // If hints is nil, insert a single, preferred any-numa hint into allProviderHints. - if len(hints) == 0 { - klog.Infof("[topologymanager] Hint Provider has no preference for NUMA affinity with any resource") - allProviderHints = append(allProviderHints, []TopologyHint{{nil, true}}) - continue - } - - // Otherwise, accumulate the hints for each resource type into allProviderHints. - for resource := range hints { - if hints[resource] == nil { - klog.Infof("[topologymanager] Hint Provider has no preference for NUMA affinity with resource '%s'", resource) - allProviderHints = append(allProviderHints, []TopologyHint{{nil, true}}) - continue - } - - if len(hints[resource]) == 0 { - klog.Infof("[topologymanager] Hint Provider has no possible NUMA affinities for resource '%s'", resource) - allProviderHints = append(allProviderHints, []TopologyHint{{nil, false}}) - continue - } - - allProviderHints = append(allProviderHints, hints[resource]) - } - } - // Iterate over all permutations of hints in 'allProviderHints'. Merge the // hints in each permutation by taking the bitwise-and of their affinity masks. // Return the hint with the narrowest NUMANodeAffinity of all merged // permutations that have at least one NUMA ID set. If no merged mask can be // found that has at least one NUMA ID set, return the 'defaultAffinity'. bestHint := TopologyHint{defaultAffinity, false} - iterateAllProviderTopologyHints(allProviderHints, func(permutation []TopologyHint) { + iterateAllProviderTopologyHints(filteredHints, func(permutation []TopologyHint) { // Get the NUMANodeAffinity from each hint in the permutation and see if any // of them encode unpreferred allocations. mergedHint := mergePermutation(p.numaNodes, permutation) diff --git a/pkg/kubelet/cm/topologymanager/policy_restricted.go b/pkg/kubelet/cm/topologymanager/policy_restricted.go index 34e3fb3c247..3a3d062389f 100644 --- a/pkg/kubelet/cm/topologymanager/policy_restricted.go +++ b/pkg/kubelet/cm/topologymanager/policy_restricted.go @@ -52,7 +52,8 @@ func (p *restrictedPolicy) canAdmitPodResult(hint *TopologyHint) lifecycle.PodAd } func (p *restrictedPolicy) Merge(providersHints []map[string][]TopologyHint) (TopologyHint, lifecycle.PodAdmitResult) { - hint := p.mergeProvidersHints(providersHints) + filteredHints := filterProvidersHints(providersHints) + hint := p.mergeProvidersHints(filteredHints) admit := p.canAdmitPodResult(&hint) return hint, admit } diff --git a/pkg/kubelet/cm/topologymanager/policy_single_numa_node.go b/pkg/kubelet/cm/topologymanager/policy_single_numa_node.go index 1aeaf23cfd4..239ae2bbbeb 100644 --- a/pkg/kubelet/cm/topologymanager/policy_single_numa_node.go +++ b/pkg/kubelet/cm/topologymanager/policy_single_numa_node.go @@ -17,7 +17,6 @@ limitations under the License. package topologymanager import ( - "k8s.io/klog" "k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/bitmask" "k8s.io/kubernetes/pkg/kubelet/lifecycle" ) @@ -72,49 +71,19 @@ func filterSingleNumaHints(allResourcesHints [][]TopologyHint) [][]TopologyHint return filteredResourcesHints } -func (p *singleNumaNodePolicy) mergeProvidersHints(providersHints []map[string][]TopologyHint) TopologyHint { +func (p *singleNumaNodePolicy) mergeProvidersHints(filteredHints [][]TopologyHint) TopologyHint { // Set the default affinity as an any-numa affinity containing the list // of NUMA Nodes available on this machine. defaultAffinity, _ := bitmask.NewBitMask(p.numaNodes...) - // Loop through all provider hints and save an accumulated list of the - // hints returned by each hint provider. If no hints are provided, assume - // that provider has no preference for topology-aware allocation. - var allProviderHints [][]TopologyHint - for _, hints := range providersHints { - // If hints is nil, insert a single, preferred any-numa hint into allProviderHints. - if len(hints) == 0 { - klog.Infof("[topologymanager] Hint Provider has no preference for NUMA affinity with any resource") - allProviderHints = append(allProviderHints, []TopologyHint{{nil, true}}) - continue - } - - // Otherwise, accumulate the hints for each resource type into allProviderHints. - for resource := range hints { - if hints[resource] == nil { - klog.Infof("[topologymanager] Hint Provider has no preference for NUMA affinity with resource '%s'", resource) - allProviderHints = append(allProviderHints, []TopologyHint{{nil, true}}) - continue - } - - if len(hints[resource]) == 0 { - klog.Infof("[topologymanager] Hint Provider has no possible NUMA affinities for resource '%s'", resource) - allProviderHints = append(allProviderHints, []TopologyHint{{nil, false}}) - continue - } - - allProviderHints = append(allProviderHints, hints[resource]) - } - } - // Filter to only include don't cares and hints with a single NUMA node. - allProviderHints = filterSingleNumaHints(allProviderHints) + filteredHints = filterSingleNumaHints(filteredHints) // Set the bestHint to return from this function as {nil false}. // This will only be returned if no better hint can be found when // merging hints from each hint provider. bestHint := TopologyHint{defaultAffinity, false} - iterateAllProviderTopologyHints(allProviderHints, func(permutation []TopologyHint) { + iterateAllProviderTopologyHints(filteredHints, func(permutation []TopologyHint) { // Get the NUMANodeAffinity from each hint in the permutation and see if any // of them encode unpreferred allocations. mergedHint := mergePermutation(p.numaNodes, permutation) @@ -158,7 +127,8 @@ func (p *singleNumaNodePolicy) mergeProvidersHints(providersHints []map[string][ } func (p *singleNumaNodePolicy) Merge(providersHints []map[string][]TopologyHint) (TopologyHint, lifecycle.PodAdmitResult) { - hint := p.mergeProvidersHints(providersHints) + filteredHints := filterProvidersHints(providersHints) + hint := p.mergeProvidersHints(filteredHints) admit := p.canAdmitPodResult(&hint) return hint, admit } From fc300e0e7d675d0863e7f5e1158a2ff37e8f72b3 Mon Sep 17 00:00:00 2001 From: nolancon Date: Wed, 22 Jan 2020 08:39:22 +0000 Subject: [PATCH 3/4] Move filterSingleNumaHints call to top level Merge --- pkg/kubelet/cm/topologymanager/policy_single_numa_node.go | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/pkg/kubelet/cm/topologymanager/policy_single_numa_node.go b/pkg/kubelet/cm/topologymanager/policy_single_numa_node.go index 239ae2bbbeb..da74c922691 100644 --- a/pkg/kubelet/cm/topologymanager/policy_single_numa_node.go +++ b/pkg/kubelet/cm/topologymanager/policy_single_numa_node.go @@ -76,9 +76,6 @@ func (p *singleNumaNodePolicy) mergeProvidersHints(filteredHints [][]TopologyHin // of NUMA Nodes available on this machine. defaultAffinity, _ := bitmask.NewBitMask(p.numaNodes...) - // Filter to only include don't cares and hints with a single NUMA node. - filteredHints = filterSingleNumaHints(filteredHints) - // Set the bestHint to return from this function as {nil false}. // This will only be returned if no better hint can be found when // merging hints from each hint provider. @@ -128,7 +125,9 @@ func (p *singleNumaNodePolicy) mergeProvidersHints(filteredHints [][]TopologyHin func (p *singleNumaNodePolicy) Merge(providersHints []map[string][]TopologyHint) (TopologyHint, lifecycle.PodAdmitResult) { filteredHints := filterProvidersHints(providersHints) - hint := p.mergeProvidersHints(filteredHints) + // Filter to only include don't cares and hints with a single NUMA node. + singleNumaHints := filterSingleNumaHints(filteredHints) + hint := p.mergeProvidersHints(singleNumaHints) admit := p.canAdmitPodResult(&hint) return hint, admit } From 4d76b1c8de798ab7b6f41899749b7918ea101c98 Mon Sep 17 00:00:00 2001 From: nolancon Date: Wed, 22 Jan 2020 09:07:41 +0000 Subject: [PATCH 4/4] Add mergeFilteredHints: - Move remaining logic from mergeProvidersHints to generic top level mergeFilteredHints function. - Add numaNodes as parameter in order to make generic. - Move single NUMA node specific check to single-numa-node Merge function. --- pkg/kubelet/cm/topologymanager/policy.go | 47 ++++++++++++++ .../cm/topologymanager/policy_best_effort.go | 58 +---------------- .../cm/topologymanager/policy_restricted.go | 2 +- .../policy_single_numa_node.go | 64 +++---------------- 4 files changed, 60 insertions(+), 111 deletions(-) diff --git a/pkg/kubelet/cm/topologymanager/policy.go b/pkg/kubelet/cm/topologymanager/policy.go index b04062a8d64..8b845578253 100644 --- a/pkg/kubelet/cm/topologymanager/policy.go +++ b/pkg/kubelet/cm/topologymanager/policy.go @@ -93,6 +93,53 @@ func filterProvidersHints(providersHints []map[string][]TopologyHint) [][]Topolo return allProviderHints } +func mergeFilteredHints(numaNodes []int, filteredHints [][]TopologyHint) TopologyHint { + // Set the default affinity as an any-numa affinity containing the list + // of NUMA Nodes available on this machine. + defaultAffinity, _ := bitmask.NewBitMask(numaNodes...) + + // Set the bestHint to return from this function as {nil false}. + // This will only be returned if no better hint can be found when + // merging hints from each hint provider. + bestHint := TopologyHint{defaultAffinity, false} + iterateAllProviderTopologyHints(filteredHints, func(permutation []TopologyHint) { + // Get the NUMANodeAffinity from each hint in the permutation and see if any + // of them encode unpreferred allocations. + mergedHint := mergePermutation(numaNodes, permutation) + // Only consider mergedHints that result in a NUMANodeAffinity > 0 to + // replace the current bestHint. + if mergedHint.NUMANodeAffinity.Count() == 0 { + return + } + + // If the current bestHint is non-preferred and the new mergedHint is + // preferred, always choose the preferred hint over the non-preferred one. + if mergedHint.Preferred && !bestHint.Preferred { + bestHint = mergedHint + return + } + + // If the current bestHint is preferred and the new mergedHint is + // non-preferred, never update bestHint, regardless of mergedHint's + // narowness. + if !mergedHint.Preferred && bestHint.Preferred { + return + } + + // If mergedHint and bestHint has the same preference, only consider + // mergedHints that have a narrower NUMANodeAffinity than the + // NUMANodeAffinity in the current bestHint. + if !mergedHint.NUMANodeAffinity.IsNarrowerThan(bestHint.NUMANodeAffinity) { + return + } + + // In all other cases, update bestHint to the current mergedHint + bestHint = mergedHint + }) + + return bestHint +} + // Iterate over all permutations of hints in 'allProviderHints [][]TopologyHint'. // // This procedure is implemented as a recursive function over the set of hints diff --git a/pkg/kubelet/cm/topologymanager/policy_best_effort.go b/pkg/kubelet/cm/topologymanager/policy_best_effort.go index 2bdf17ba995..1f02094a045 100644 --- a/pkg/kubelet/cm/topologymanager/policy_best_effort.go +++ b/pkg/kubelet/cm/topologymanager/policy_best_effort.go @@ -17,7 +17,6 @@ limitations under the License. package topologymanager import ( - "k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/bitmask" "k8s.io/kubernetes/pkg/kubelet/lifecycle" ) @@ -48,58 +47,7 @@ func (p *bestEffortPolicy) canAdmitPodResult(hint *TopologyHint) lifecycle.PodAd func (p *bestEffortPolicy) Merge(providersHints []map[string][]TopologyHint) (TopologyHint, lifecycle.PodAdmitResult) { filteredProvidersHints := filterProvidersHints(providersHints) - hint := p.mergeProvidersHints(filteredProvidersHints) - admit := p.canAdmitPodResult(&hint) - return hint, admit -} - -// Merge the hints from all hint providers to find the best one. -func (p *bestEffortPolicy) mergeProvidersHints(filteredHints [][]TopologyHint) TopologyHint { - // Set the default affinity as an any-numa affinity containing the list - // of NUMA Nodes available on this machine. - defaultAffinity, _ := bitmask.NewBitMask(p.numaNodes...) - - // Iterate over all permutations of hints in 'allProviderHints'. Merge the - // hints in each permutation by taking the bitwise-and of their affinity masks. - // Return the hint with the narrowest NUMANodeAffinity of all merged - // permutations that have at least one NUMA ID set. If no merged mask can be - // found that has at least one NUMA ID set, return the 'defaultAffinity'. - bestHint := TopologyHint{defaultAffinity, false} - iterateAllProviderTopologyHints(filteredHints, func(permutation []TopologyHint) { - // Get the NUMANodeAffinity from each hint in the permutation and see if any - // of them encode unpreferred allocations. - mergedHint := mergePermutation(p.numaNodes, permutation) - - // Only consider mergedHints that result in a NUMANodeAffinity > 0 to - // replace the current bestHint. - if mergedHint.NUMANodeAffinity.Count() == 0 { - return - } - - // If the current bestHint is non-preferred and the new mergedHint is - // preferred, always choose the preferred hint over the non-preferred one. - if mergedHint.Preferred && !bestHint.Preferred { - bestHint = mergedHint - return - } - - // If the current bestHint is preferred and the new mergedHint is - // non-preferred, never update bestHint, regardless of mergedHint's - // narowness. - if !mergedHint.Preferred && bestHint.Preferred { - return - } - - // If mergedHint and bestHint has the same preference, only consider - // mergedHints that have a narrower NUMANodeAffinity than the - // NUMANodeAffinity in the current bestHint. - if !mergedHint.NUMANodeAffinity.IsNarrowerThan(bestHint.NUMANodeAffinity) { - return - } - - // In all other cases, update bestHint to the current mergedHint - bestHint = mergedHint - }) - - return bestHint + bestHint := mergeFilteredHints(p.numaNodes, filteredProvidersHints) + admit := p.canAdmitPodResult(&bestHint) + return bestHint, admit } diff --git a/pkg/kubelet/cm/topologymanager/policy_restricted.go b/pkg/kubelet/cm/topologymanager/policy_restricted.go index 3a3d062389f..e7882083b98 100644 --- a/pkg/kubelet/cm/topologymanager/policy_restricted.go +++ b/pkg/kubelet/cm/topologymanager/policy_restricted.go @@ -53,7 +53,7 @@ func (p *restrictedPolicy) canAdmitPodResult(hint *TopologyHint) lifecycle.PodAd func (p *restrictedPolicy) Merge(providersHints []map[string][]TopologyHint) (TopologyHint, lifecycle.PodAdmitResult) { filteredHints := filterProvidersHints(providersHints) - hint := p.mergeProvidersHints(filteredHints) + hint := mergeFilteredHints(p.numaNodes, filteredHints) admit := p.canAdmitPodResult(&hint) return hint, admit } diff --git a/pkg/kubelet/cm/topologymanager/policy_single_numa_node.go b/pkg/kubelet/cm/topologymanager/policy_single_numa_node.go index da74c922691..224d4686ac7 100644 --- a/pkg/kubelet/cm/topologymanager/policy_single_numa_node.go +++ b/pkg/kubelet/cm/topologymanager/policy_single_numa_node.go @@ -71,63 +71,17 @@ func filterSingleNumaHints(allResourcesHints [][]TopologyHint) [][]TopologyHint return filteredResourcesHints } -func (p *singleNumaNodePolicy) mergeProvidersHints(filteredHints [][]TopologyHint) TopologyHint { - // Set the default affinity as an any-numa affinity containing the list - // of NUMA Nodes available on this machine. - defaultAffinity, _ := bitmask.NewBitMask(p.numaNodes...) - - // Set the bestHint to return from this function as {nil false}. - // This will only be returned if no better hint can be found when - // merging hints from each hint provider. - bestHint := TopologyHint{defaultAffinity, false} - iterateAllProviderTopologyHints(filteredHints, func(permutation []TopologyHint) { - // Get the NUMANodeAffinity from each hint in the permutation and see if any - // of them encode unpreferred allocations. - mergedHint := mergePermutation(p.numaNodes, permutation) - - // Only consider mergedHints that result in a NUMANodeAffinity > 0 to - // replace the current bestHint. - if mergedHint.NUMANodeAffinity.Count() == 0 { - return - } - - // If the current bestHint is non-preferred and the new mergedHint is - // preferred, always choose the preferred hint over the non-preferred one. - if mergedHint.Preferred && !bestHint.Preferred { - bestHint = mergedHint - return - } - - // If the current bestHint is preferred and the new mergedHint is - // non-preferred, never update bestHint, regardless of mergedHint's - // narowness. - if !mergedHint.Preferred && bestHint.Preferred { - return - } - - // If mergedHint and bestHint has the same preference, only consider - // mergedHints that have a narrower NUMANodeAffinity than the - // NUMANodeAffinity in the current bestHint. - if !mergedHint.NUMANodeAffinity.IsNarrowerThan(bestHint.NUMANodeAffinity) { - return - } - - // In all other cases, update bestHint to the current mergedHint - bestHint = mergedHint - }) - - if bestHint.NUMANodeAffinity.IsEqual(defaultAffinity) { - bestHint = TopologyHint{nil, bestHint.Preferred} - } - - return bestHint -} - func (p *singleNumaNodePolicy) Merge(providersHints []map[string][]TopologyHint) (TopologyHint, lifecycle.PodAdmitResult) { filteredHints := filterProvidersHints(providersHints) // Filter to only include don't cares and hints with a single NUMA node. singleNumaHints := filterSingleNumaHints(filteredHints) - hint := p.mergeProvidersHints(singleNumaHints) - admit := p.canAdmitPodResult(&hint) - return hint, admit + bestHint := mergeFilteredHints(p.numaNodes, singleNumaHints) + + defaultAffinity, _ := bitmask.NewBitMask(p.numaNodes...) + if bestHint.NUMANodeAffinity.IsEqual(defaultAffinity) { + bestHint = TopologyHint{nil, bestHint.Preferred} + } + + admit := p.canAdmitPodResult(&bestHint) + return bestHint, admit }