mirror of
https://github.com/k3s-io/kubernetes.git
synced 2025-07-22 11:21:47 +00:00
Merge pull request #83033 from ConnorDoyle/rename-socketmask
Rename package socketmask to bitmask.
This commit is contained in:
commit
4e63af2324
@ -20,7 +20,7 @@ go_library(
|
||||
"//pkg/kubelet/cm/cpumanager/topology:go_default_library",
|
||||
"//pkg/kubelet/cm/cpuset:go_default_library",
|
||||
"//pkg/kubelet/cm/topologymanager:go_default_library",
|
||||
"//pkg/kubelet/cm/topologymanager/socketmask:go_default_library",
|
||||
"//pkg/kubelet/cm/topologymanager/bitmask:go_default_library",
|
||||
"//pkg/kubelet/container:go_default_library",
|
||||
"//pkg/kubelet/status:go_default_library",
|
||||
"//staging/src/k8s.io/api/core/v1:go_default_library",
|
||||
@ -48,7 +48,7 @@ go_test(
|
||||
"//pkg/kubelet/cm/cpumanager/topology:go_default_library",
|
||||
"//pkg/kubelet/cm/cpuset:go_default_library",
|
||||
"//pkg/kubelet/cm/topologymanager:go_default_library",
|
||||
"//pkg/kubelet/cm/topologymanager/socketmask:go_default_library",
|
||||
"//pkg/kubelet/cm/topologymanager/bitmask:go_default_library",
|
||||
"//staging/src/k8s.io/api/core/v1:go_default_library",
|
||||
"//staging/src/k8s.io/apimachinery/pkg/api/resource:go_default_library",
|
||||
"//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
|
||||
|
@ -26,7 +26,7 @@ import (
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/cpumanager/topology"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/cpuset"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/socketmask"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/bitmask"
|
||||
)
|
||||
|
||||
// PolicyStatic is the name of the static policy
|
||||
@ -250,14 +250,14 @@ func (p *staticPolicy) RemoveContainer(s state.State, containerID string) (rerr
|
||||
return nil
|
||||
}
|
||||
|
||||
func (p *staticPolicy) allocateCPUs(s state.State, numCPUs int, numaAffinity socketmask.SocketMask) (cpuset.CPUSet, error) {
|
||||
func (p *staticPolicy) allocateCPUs(s state.State, numCPUs int, numaAffinity bitmask.BitMask) (cpuset.CPUSet, error) {
|
||||
klog.Infof("[cpumanager] allocateCpus: (numCPUs: %d, socket: %v)", numCPUs, numaAffinity)
|
||||
|
||||
// If there are aligned CPUs in numaAffinity, attempt to take those first.
|
||||
result := cpuset.NewCPUSet()
|
||||
if numaAffinity != nil {
|
||||
alignedCPUs := cpuset.NewCPUSet()
|
||||
for _, numaNodeID := range numaAffinity.GetSockets() {
|
||||
for _, numaNodeID := range numaAffinity.GetBits() {
|
||||
alignedCPUs = alignedCPUs.Union(p.assignableCPUs(s).Intersection(p.topology.CPUDetails.CPUsInNUMANodes(numaNodeID)))
|
||||
}
|
||||
|
||||
|
@ -26,7 +26,7 @@ import (
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/cpumanager/topology"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/cpuset"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/socketmask"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/bitmask"
|
||||
)
|
||||
|
||||
type staticPolicyTest struct {
|
||||
@ -746,11 +746,11 @@ func TestTopologyAwareAllocateCPUs(t *testing.T) {
|
||||
stAssignments state.ContainerCPUAssignments
|
||||
stDefaultCPUSet cpuset.CPUSet
|
||||
numRequested int
|
||||
socketMask socketmask.SocketMask
|
||||
socketMask bitmask.BitMask
|
||||
expCSet cpuset.CPUSet
|
||||
}{
|
||||
{
|
||||
description: "Request 2 CPUs, No SocketMask",
|
||||
description: "Request 2 CPUs, No BitMask",
|
||||
topo: topoDualSocketHT,
|
||||
stAssignments: state.ContainerCPUAssignments{},
|
||||
stDefaultCPUSet: cpuset.NewCPUSet(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11),
|
||||
@ -759,49 +759,49 @@ func TestTopologyAwareAllocateCPUs(t *testing.T) {
|
||||
expCSet: cpuset.NewCPUSet(0, 6),
|
||||
},
|
||||
{
|
||||
description: "Request 2 CPUs, SocketMask on Socket 0",
|
||||
description: "Request 2 CPUs, BitMask on Socket 0",
|
||||
topo: topoDualSocketHT,
|
||||
stAssignments: state.ContainerCPUAssignments{},
|
||||
stDefaultCPUSet: cpuset.NewCPUSet(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11),
|
||||
numRequested: 2,
|
||||
socketMask: func() socketmask.SocketMask {
|
||||
mask, _ := socketmask.NewSocketMask(0)
|
||||
socketMask: func() bitmask.BitMask {
|
||||
mask, _ := bitmask.NewBitMask(0)
|
||||
return mask
|
||||
}(),
|
||||
expCSet: cpuset.NewCPUSet(0, 6),
|
||||
},
|
||||
{
|
||||
description: "Request 2 CPUs, SocketMask on Socket 1",
|
||||
description: "Request 2 CPUs, BitMask on Socket 1",
|
||||
topo: topoDualSocketHT,
|
||||
stAssignments: state.ContainerCPUAssignments{},
|
||||
stDefaultCPUSet: cpuset.NewCPUSet(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11),
|
||||
numRequested: 2,
|
||||
socketMask: func() socketmask.SocketMask {
|
||||
mask, _ := socketmask.NewSocketMask(1)
|
||||
socketMask: func() bitmask.BitMask {
|
||||
mask, _ := bitmask.NewBitMask(1)
|
||||
return mask
|
||||
}(),
|
||||
expCSet: cpuset.NewCPUSet(1, 7),
|
||||
},
|
||||
{
|
||||
description: "Request 8 CPUs, SocketMask on Socket 0",
|
||||
description: "Request 8 CPUs, BitMask on Socket 0",
|
||||
topo: topoDualSocketHT,
|
||||
stAssignments: state.ContainerCPUAssignments{},
|
||||
stDefaultCPUSet: cpuset.NewCPUSet(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11),
|
||||
numRequested: 8,
|
||||
socketMask: func() socketmask.SocketMask {
|
||||
mask, _ := socketmask.NewSocketMask(0)
|
||||
socketMask: func() bitmask.BitMask {
|
||||
mask, _ := bitmask.NewBitMask(0)
|
||||
return mask
|
||||
}(),
|
||||
expCSet: cpuset.NewCPUSet(0, 6, 2, 8, 4, 10, 1, 7),
|
||||
},
|
||||
{
|
||||
description: "Request 8 CPUs, SocketMask on Socket 1",
|
||||
description: "Request 8 CPUs, BitMask on Socket 1",
|
||||
topo: topoDualSocketHT,
|
||||
stAssignments: state.ContainerCPUAssignments{},
|
||||
stDefaultCPUSet: cpuset.NewCPUSet(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11),
|
||||
numRequested: 8,
|
||||
socketMask: func() socketmask.SocketMask {
|
||||
mask, _ := socketmask.NewSocketMask(1)
|
||||
socketMask: func() bitmask.BitMask {
|
||||
mask, _ := bitmask.NewBitMask(1)
|
||||
return mask
|
||||
}(),
|
||||
expCSet: cpuset.NewCPUSet(1, 7, 3, 9, 5, 11, 0, 6),
|
||||
|
@ -22,7 +22,7 @@ import (
|
||||
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/cpuset"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/socketmask"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/bitmask"
|
||||
)
|
||||
|
||||
func (m *manager) GetTopologyHints(pod v1.Pod, container v1.Container) map[string][]topologymanager.TopologyHint {
|
||||
@ -76,13 +76,13 @@ func (m *manager) generateCPUTopologyHints(availableCPUs cpuset.CPUSet, request
|
||||
// Initialize minSocketsOnMinAffinity to include all Sockets.
|
||||
minSocketsOnMinAffinity := m.topology.CPUDetails.Sockets().Size()
|
||||
|
||||
// Iterate through all combinations of socketMasks and build hints from them.
|
||||
// Iterate through all combinations of bitmasks and build hints from them.
|
||||
hints := []topologymanager.TopologyHint{}
|
||||
socketmask.IterateSocketMasks(m.topology.CPUDetails.NUMANodes().ToSlice(), func(mask socketmask.SocketMask) {
|
||||
bitmask.IterateBitMasks(m.topology.CPUDetails.NUMANodes().ToSlice(), func(mask bitmask.BitMask) {
|
||||
// First, update minAffinitySize and minSocketsOnMinAffinity for the
|
||||
// current request size.
|
||||
cpusInMask := m.topology.CPUDetails.CPUsInNUMANodes(mask.GetSockets()...).Size()
|
||||
socketsInMask := m.topology.CPUDetails.SocketsInNUMANodes(mask.GetSockets()...).Size()
|
||||
cpusInMask := m.topology.CPUDetails.CPUsInNUMANodes(mask.GetBits()...).Size()
|
||||
socketsInMask := m.topology.CPUDetails.SocketsInNUMANodes(mask.GetBits()...).Size()
|
||||
if cpusInMask >= request && mask.Count() < minAffinitySize {
|
||||
minAffinitySize = mask.Count()
|
||||
if socketsInMask < minSocketsOnMinAffinity {
|
||||
@ -91,7 +91,7 @@ func (m *manager) generateCPUTopologyHints(availableCPUs cpuset.CPUSet, request
|
||||
}
|
||||
|
||||
// Then check to see if we have enough CPUs available on the current
|
||||
// SocketMask to satisfy the CPU request.
|
||||
// Socket bitmask to satisfy the CPU request.
|
||||
numMatching := 0
|
||||
for _, c := range availableCPUs.ToSlice() {
|
||||
if mask.IsSet(m.topology.CPUDetails[c].NUMANodeID) {
|
||||
@ -104,7 +104,7 @@ func (m *manager) generateCPUTopologyHints(availableCPUs cpuset.CPUSet, request
|
||||
return
|
||||
}
|
||||
|
||||
// Otherwise, create a new hint from the SocketMask and add it to the
|
||||
// Otherwise, create a new hint from the socket bitmask and add it to the
|
||||
// list of hints. We set all hint preferences to 'false' on the first
|
||||
// pass through.
|
||||
hints = append(hints, topologymanager.TopologyHint{
|
||||
@ -119,7 +119,7 @@ func (m *manager) generateCPUTopologyHints(availableCPUs cpuset.CPUSet, request
|
||||
// with a minimal set of sockets) will be considered preferred.
|
||||
for i := range hints {
|
||||
if hints[i].NUMANodeAffinity.Count() == minAffinitySize {
|
||||
nodes := hints[i].NUMANodeAffinity.GetSockets()
|
||||
nodes := hints[i].NUMANodeAffinity.GetBits()
|
||||
numSockets := m.topology.CPUDetails.SocketsInNUMANodes(nodes...).Size()
|
||||
if numSockets == minSocketsOnMinAffinity {
|
||||
hints[i].Preferred = true
|
||||
|
@ -26,7 +26,7 @@ import (
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/cpumanager/topology"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/cpuset"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/socketmask"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/bitmask"
|
||||
)
|
||||
|
||||
func topologyHintLessThan(a topologymanager.TopologyHint, b topologymanager.TopologyHint) bool {
|
||||
@ -46,9 +46,9 @@ func TestGetTopologyHints(t *testing.T) {
|
||||
testPod4 := makePod("11", "11")
|
||||
testContainer4 := &testPod4.Spec.Containers[0]
|
||||
|
||||
firstSocketMask, _ := socketmask.NewSocketMask(0)
|
||||
secondSocketMask, _ := socketmask.NewSocketMask(1)
|
||||
crossSocketMask, _ := socketmask.NewSocketMask(0, 1)
|
||||
firstSocketMask, _ := bitmask.NewBitMask(0)
|
||||
secondSocketMask, _ := bitmask.NewBitMask(1)
|
||||
crossSocketMask, _ := bitmask.NewBitMask(0, 1)
|
||||
|
||||
machineInfo := cadvisorapi.MachineInfo{
|
||||
NumCores: 12,
|
||||
|
@ -24,7 +24,7 @@ go_library(
|
||||
"//pkg/kubelet/cm/cpumanager/topology:go_default_library",
|
||||
"//pkg/kubelet/cm/devicemanager/checkpoint:go_default_library",
|
||||
"//pkg/kubelet/cm/topologymanager:go_default_library",
|
||||
"//pkg/kubelet/cm/topologymanager/socketmask:go_default_library",
|
||||
"//pkg/kubelet/cm/topologymanager/bitmask:go_default_library",
|
||||
"//pkg/kubelet/config:go_default_library",
|
||||
"//pkg/kubelet/container:go_default_library",
|
||||
"//pkg/kubelet/lifecycle:go_default_library",
|
||||
@ -54,7 +54,7 @@ go_test(
|
||||
"//pkg/kubelet/apis/pluginregistration/v1:go_default_library",
|
||||
"//pkg/kubelet/checkpointmanager:go_default_library",
|
||||
"//pkg/kubelet/cm/topologymanager:go_default_library",
|
||||
"//pkg/kubelet/cm/topologymanager/socketmask:go_default_library",
|
||||
"//pkg/kubelet/cm/topologymanager/bitmask:go_default_library",
|
||||
"//pkg/kubelet/config:go_default_library",
|
||||
"//pkg/kubelet/lifecycle:go_default_library",
|
||||
"//pkg/kubelet/pluginmanager:go_default_library",
|
||||
|
@ -42,7 +42,7 @@ import (
|
||||
cputopology "k8s.io/kubernetes/pkg/kubelet/cm/cpumanager/topology"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/devicemanager/checkpoint"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/socketmask"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/bitmask"
|
||||
"k8s.io/kubernetes/pkg/kubelet/config"
|
||||
"k8s.io/kubernetes/pkg/kubelet/lifecycle"
|
||||
"k8s.io/kubernetes/pkg/kubelet/metrics"
|
||||
@ -674,7 +674,7 @@ func (m *ManagerImpl) devicesToAllocate(podUID, contName, resource string, requi
|
||||
return devices, nil
|
||||
}
|
||||
|
||||
func (m *ManagerImpl) takeByTopology(resource string, available sets.String, affinity socketmask.SocketMask, request int) []string {
|
||||
func (m *ManagerImpl) takeByTopology(resource string, available sets.String, affinity bitmask.BitMask, request int) []string {
|
||||
// Build a map of of NUMA Nodes to the devices associated with them. A
|
||||
// device may be associated to multiple NUMA nodes at the same time. If an
|
||||
// available device does not have any NUMA Nodes associated with it, add it
|
||||
|
@ -21,7 +21,7 @@ import (
|
||||
"k8s.io/apimachinery/pkg/util/sets"
|
||||
"k8s.io/klog"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/socketmask"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/bitmask"
|
||||
)
|
||||
|
||||
// GetTopologyHints implements the TopologyManager HintProvider Interface which
|
||||
@ -78,7 +78,7 @@ func (m *ManagerImpl) generateDeviceTopologyHints(resource string, devices sets.
|
||||
|
||||
// Iterate through all combinations of NUMA Nodes and build hints from them.
|
||||
hints := []topologymanager.TopologyHint{}
|
||||
socketmask.IterateSocketMasks(m.numaNodes, func(mask socketmask.SocketMask) {
|
||||
bitmask.IterateBitMasks(m.numaNodes, func(mask bitmask.BitMask) {
|
||||
// First, update minAffinitySize for the current request size.
|
||||
devicesInMask := 0
|
||||
for _, device := range m.allDevices[resource] {
|
||||
|
@ -26,7 +26,7 @@ import (
|
||||
"k8s.io/apimachinery/pkg/util/sets"
|
||||
pluginapi "k8s.io/kubernetes/pkg/kubelet/apis/deviceplugin/v1beta1"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/socketmask"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/bitmask"
|
||||
)
|
||||
|
||||
type mockAffinityStore struct {
|
||||
@ -51,8 +51,8 @@ func topologyHintLessThan(a topologymanager.TopologyHint, b topologymanager.Topo
|
||||
return a.NUMANodeAffinity.IsNarrowerThan(b.NUMANodeAffinity)
|
||||
}
|
||||
|
||||
func makeSocketMask(sockets ...int) socketmask.SocketMask {
|
||||
mask, _ := socketmask.NewSocketMask(sockets...)
|
||||
func makeSocketMask(sockets ...int) bitmask.BitMask {
|
||||
mask, _ := bitmask.NewBitMask(sockets...)
|
||||
return mask
|
||||
}
|
||||
|
||||
|
@ -15,7 +15,7 @@ go_library(
|
||||
visibility = ["//visibility:public"],
|
||||
deps = [
|
||||
"//pkg/kubelet/cm/cpumanager/topology:go_default_library",
|
||||
"//pkg/kubelet/cm/topologymanager/socketmask:go_default_library",
|
||||
"//pkg/kubelet/cm/topologymanager/bitmask:go_default_library",
|
||||
"//pkg/kubelet/lifecycle:go_default_library",
|
||||
"//staging/src/k8s.io/api/core/v1:go_default_library",
|
||||
"//vendor/k8s.io/klog:go_default_library",
|
||||
@ -33,7 +33,7 @@ filegroup(
|
||||
name = "all-srcs",
|
||||
srcs = [
|
||||
":package-srcs",
|
||||
"//pkg/kubelet/cm/topologymanager/socketmask:all-srcs",
|
||||
"//pkg/kubelet/cm/topologymanager/bitmask:all-srcs",
|
||||
],
|
||||
tags = ["automanaged"],
|
||||
visibility = ["//visibility:public"],
|
||||
@ -51,7 +51,7 @@ go_test(
|
||||
],
|
||||
embed = [":go_default_library"],
|
||||
deps = [
|
||||
"//pkg/kubelet/cm/topologymanager/socketmask:go_default_library",
|
||||
"//pkg/kubelet/cm/topologymanager/bitmask:go_default_library",
|
||||
"//pkg/kubelet/lifecycle:go_default_library",
|
||||
"//staging/src/k8s.io/api/core/v1:go_default_library",
|
||||
"//staging/src/k8s.io/apimachinery/pkg/types:go_default_library",
|
||||
|
@ -2,8 +2,8 @@ load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
|
||||
|
||||
go_library(
|
||||
name = "go_default_library",
|
||||
srcs = ["socketmask.go"],
|
||||
importpath = "k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/socketmask",
|
||||
srcs = ["bitmask.go"],
|
||||
importpath = "k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/bitmask",
|
||||
visibility = ["//visibility:public"],
|
||||
)
|
||||
|
||||
@ -23,6 +23,6 @@ filegroup(
|
||||
|
||||
go_test(
|
||||
name = "go_default_test",
|
||||
srcs = ["socketmask_test.go"],
|
||||
srcs = ["bitmask_test.go"],
|
||||
embed = [":go_default_library"],
|
||||
)
|
194
pkg/kubelet/cm/topologymanager/bitmask/bitmask.go
Normal file
194
pkg/kubelet/cm/topologymanager/bitmask/bitmask.go
Normal file
@ -0,0 +1,194 @@
|
||||
/*
|
||||
Copyright 2019 The Kubernetes Authors.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
|
||||
package bitmask
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math/bits"
|
||||
)
|
||||
|
||||
// BitMask interface allows hint providers to create BitMasks for TopologyHints
|
||||
type BitMask interface {
|
||||
Add(bits ...int) error
|
||||
Remove(bits ...int) error
|
||||
And(masks ...BitMask)
|
||||
Or(masks ...BitMask)
|
||||
Clear()
|
||||
Fill()
|
||||
IsEqual(mask BitMask) bool
|
||||
IsEmpty() bool
|
||||
IsSet(bit int) bool
|
||||
IsNarrowerThan(mask BitMask) bool
|
||||
String() string
|
||||
Count() int
|
||||
GetBits() []int
|
||||
}
|
||||
|
||||
type bitMask uint64
|
||||
|
||||
// NewEmptyBitMask creates a new, empty BitMask
|
||||
func NewEmptyBitMask() BitMask {
|
||||
s := bitMask(0)
|
||||
return &s
|
||||
}
|
||||
|
||||
// NewBitMask creates a new BitMask
|
||||
func NewBitMask(bits ...int) (BitMask, error) {
|
||||
s := bitMask(0)
|
||||
err := (&s).Add(bits...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &s, nil
|
||||
}
|
||||
|
||||
// Add adds the bits with topology affinity to the BitMask
|
||||
func (s *bitMask) Add(bits ...int) error {
|
||||
mask := *s
|
||||
for _, i := range bits {
|
||||
if i < 0 || i >= 64 {
|
||||
return fmt.Errorf("bit number must be in range 0-63")
|
||||
}
|
||||
mask |= 1 << uint64(i)
|
||||
}
|
||||
*s = mask
|
||||
return nil
|
||||
}
|
||||
|
||||
// Remove removes specified bits from BitMask
|
||||
func (s *bitMask) Remove(bits ...int) error {
|
||||
mask := *s
|
||||
for _, i := range bits {
|
||||
if i < 0 || i >= 64 {
|
||||
return fmt.Errorf("bit number must be in range 0-63")
|
||||
}
|
||||
mask &^= 1 << uint64(i)
|
||||
}
|
||||
*s = mask
|
||||
return nil
|
||||
}
|
||||
|
||||
// And performs and operation on all bits in masks
|
||||
func (s *bitMask) And(masks ...BitMask) {
|
||||
for _, m := range masks {
|
||||
*s &= *m.(*bitMask)
|
||||
}
|
||||
}
|
||||
|
||||
// Or performs or operation on all bits in masks
|
||||
func (s *bitMask) Or(masks ...BitMask) {
|
||||
for _, m := range masks {
|
||||
*s |= *m.(*bitMask)
|
||||
}
|
||||
}
|
||||
|
||||
// Clear resets all bits in mask to zero
|
||||
func (s *bitMask) Clear() {
|
||||
*s = 0
|
||||
}
|
||||
|
||||
// Fill sets all bits in mask to one
|
||||
func (s *bitMask) Fill() {
|
||||
*s = bitMask(^uint64(0))
|
||||
}
|
||||
|
||||
// IsEmpty checks mask to see if all bits are zero
|
||||
func (s *bitMask) IsEmpty() bool {
|
||||
return *s == 0
|
||||
}
|
||||
|
||||
// IsSet checks bit in mask to see if bit is set to one
|
||||
func (s *bitMask) IsSet(bit int) bool {
|
||||
if bit < 0 || bit >= 64 {
|
||||
return false
|
||||
}
|
||||
return (*s & (1 << uint64(bit))) > 0
|
||||
}
|
||||
|
||||
// IsEqual checks if masks are equal
|
||||
func (s *bitMask) IsEqual(mask BitMask) bool {
|
||||
return *s == *mask.(*bitMask)
|
||||
}
|
||||
|
||||
// IsNarrowerThan checks if one mask is narrower than another.
|
||||
//
|
||||
// A mask is said to be "narrower" than another if it has lets bits set. If the
|
||||
// same number of bits are set in both masks, then the mask with more
|
||||
// lower-numbered bits set wins out.
|
||||
func (s *bitMask) IsNarrowerThan(mask BitMask) bool {
|
||||
if s.Count() == mask.Count() {
|
||||
if *s < *mask.(*bitMask) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return s.Count() < mask.Count()
|
||||
}
|
||||
|
||||
// String converts mask to string
|
||||
func (s *bitMask) String() string {
|
||||
return fmt.Sprintf("%064b", *s)
|
||||
}
|
||||
|
||||
// Count counts number of bits in mask set to one
|
||||
func (s *bitMask) Count() int {
|
||||
return bits.OnesCount64(uint64(*s))
|
||||
}
|
||||
|
||||
// Getbits returns each bit number with bits set to one
|
||||
func (s *bitMask) GetBits() []int {
|
||||
var bits []int
|
||||
for i := uint64(0); i < 64; i++ {
|
||||
if (*s & (1 << i)) > 0 {
|
||||
bits = append(bits, int(i))
|
||||
}
|
||||
}
|
||||
return bits
|
||||
}
|
||||
|
||||
// And is a package level implementation of 'and' between first and masks
|
||||
func And(first BitMask, masks ...BitMask) BitMask {
|
||||
s := *first.(*bitMask)
|
||||
s.And(masks...)
|
||||
return &s
|
||||
}
|
||||
|
||||
// Or is a package level implementation of 'or' between first and masks
|
||||
func Or(first BitMask, masks ...BitMask) BitMask {
|
||||
s := *first.(*bitMask)
|
||||
s.Or(masks...)
|
||||
return &s
|
||||
}
|
||||
|
||||
// IterateBitMasks iterates all possible masks from a list of bits,
|
||||
// issuing a callback on each mask.
|
||||
func IterateBitMasks(bits []int, callback func(BitMask)) {
|
||||
var iterate func(bits, accum []int, size int)
|
||||
iterate = func(bits, accum []int, size int) {
|
||||
if len(accum) == size {
|
||||
mask, _ := NewBitMask(accum...)
|
||||
callback(mask)
|
||||
return
|
||||
}
|
||||
for i := range bits {
|
||||
iterate(bits[i+1:], append(accum, bits[i]), size)
|
||||
}
|
||||
}
|
||||
|
||||
for i := 1; i <= len(bits); i++ {
|
||||
iterate(bits, []int{}, i)
|
||||
}
|
||||
}
|
@ -14,27 +14,27 @@ See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
|
||||
package socketmask
|
||||
package bitmask
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestNewSocketMask(t *testing.T) {
|
||||
func TestNewBitMask(t *testing.T) {
|
||||
tcases := []struct {
|
||||
name string
|
||||
socket int
|
||||
bit int
|
||||
expectedMask string
|
||||
}{
|
||||
{
|
||||
name: "New SocketMask with socket 0 set",
|
||||
socket: 0,
|
||||
name: "New BitMask with bit 0 set",
|
||||
bit: 0,
|
||||
expectedMask: "0000000000000000000000000000000000000000000000000000000000000001",
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
sm, _ := NewSocketMask(0)
|
||||
sm, _ := NewBitMask(0)
|
||||
if sm.String() != tc.expectedMask {
|
||||
t.Errorf("Expected mask to be %v, got %v", tc.expectedMask, sm)
|
||||
}
|
||||
@ -44,20 +44,20 @@ func TestNewSocketMask(t *testing.T) {
|
||||
func TestAdd(t *testing.T) {
|
||||
tcases := []struct {
|
||||
name string
|
||||
firstSocket int
|
||||
secondSocket int
|
||||
firstbit int
|
||||
secondbit int
|
||||
expectedMask string
|
||||
}{
|
||||
{
|
||||
name: "New SocketMask with sockets 0 and 1 set",
|
||||
firstSocket: 0,
|
||||
secondSocket: 1,
|
||||
name: "New BitMask with bits 0 and 1 set",
|
||||
firstbit: 0,
|
||||
secondbit: 1,
|
||||
expectedMask: "0000000000000000000000000000000000000000000000000000000000000011",
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
mask, _ := NewSocketMask()
|
||||
mask.Add(tc.firstSocket, tc.secondSocket)
|
||||
mask, _ := NewBitMask()
|
||||
mask.Add(tc.firstbit, tc.secondbit)
|
||||
if mask.String() != tc.expectedMask {
|
||||
t.Errorf("Expected mask to be %v, got %v", tc.expectedMask, mask)
|
||||
}
|
||||
@ -67,22 +67,22 @@ func TestAdd(t *testing.T) {
|
||||
func TestRemove(t *testing.T) {
|
||||
tcases := []struct {
|
||||
name string
|
||||
firstSocketSet int
|
||||
secondSocketSet int
|
||||
firstSocketRemove int
|
||||
firstbitset int
|
||||
secondbitset int
|
||||
firstbitRemove int
|
||||
expectedMask string
|
||||
}{
|
||||
{
|
||||
name: "Reset bit 1 SocketMask to 0",
|
||||
firstSocketSet: 0,
|
||||
secondSocketSet: 1,
|
||||
firstSocketRemove: 0,
|
||||
name: "Reset bit 1 BitMask to 0",
|
||||
firstbitset: 0,
|
||||
secondbitset: 1,
|
||||
firstbitRemove: 0,
|
||||
expectedMask: "0000000000000000000000000000000000000000000000000000000000000010",
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
mask, _ := NewSocketMask(tc.firstSocketSet, tc.secondSocketSet)
|
||||
mask.Remove(tc.firstSocketRemove)
|
||||
mask, _ := NewBitMask(tc.firstbitset, tc.secondbitset)
|
||||
mask.Remove(tc.firstbitRemove)
|
||||
if mask.String() != tc.expectedMask {
|
||||
t.Errorf("Expected mask to be %v, got %v", tc.expectedMask, mask)
|
||||
}
|
||||
@ -97,15 +97,15 @@ func TestAnd(t *testing.T) {
|
||||
andMask string
|
||||
}{
|
||||
{
|
||||
name: "And socket masks",
|
||||
name: "And bit masks",
|
||||
firstMaskBit: 0,
|
||||
secondMaskBit: 0,
|
||||
andMask: "0000000000000000000000000000000000000000000000000000000000000001",
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
firstMask, _ := NewSocketMask(tc.firstMaskBit)
|
||||
secondMask, _ := NewSocketMask(tc.secondMaskBit)
|
||||
firstMask, _ := NewBitMask(tc.firstMaskBit)
|
||||
secondMask, _ := NewBitMask(tc.secondMaskBit)
|
||||
|
||||
result := And(firstMask, secondMask)
|
||||
if result.String() != string(tc.andMask) {
|
||||
@ -127,15 +127,15 @@ func TestOr(t *testing.T) {
|
||||
orMask string
|
||||
}{
|
||||
{
|
||||
name: "Or socket masks",
|
||||
name: "Or bit masks",
|
||||
firstMaskBit: 0,
|
||||
secondMaskBit: 1,
|
||||
orMask: "0000000000000000000000000000000000000000000000000000000000000011",
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
firstMask, _ := NewSocketMask(tc.firstMaskBit)
|
||||
secondMask, _ := NewSocketMask(tc.secondMaskBit)
|
||||
firstMask, _ := NewBitMask(tc.firstMaskBit)
|
||||
secondMask, _ := NewBitMask(tc.secondMaskBit)
|
||||
|
||||
result := Or(firstMask, secondMask)
|
||||
if result.String() != string(tc.orMask) {
|
||||
@ -157,14 +157,14 @@ func TestClear(t *testing.T) {
|
||||
clearedMask string
|
||||
}{
|
||||
{
|
||||
name: "Clear socket masks",
|
||||
name: "Clear bit masks",
|
||||
firstBit: 0,
|
||||
secondBit: 1,
|
||||
clearedMask: "0000000000000000000000000000000000000000000000000000000000000000",
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
mask, _ := NewSocketMask(tc.firstBit, tc.secondBit)
|
||||
mask, _ := NewBitMask(tc.firstBit, tc.secondBit)
|
||||
mask.Clear()
|
||||
if mask.String() != string(tc.clearedMask) {
|
||||
t.Errorf("Expected mask to be %v, got %v", tc.clearedMask, mask)
|
||||
@ -178,12 +178,12 @@ func TestFill(t *testing.T) {
|
||||
filledMask string
|
||||
}{
|
||||
{
|
||||
name: "Fill socket masks",
|
||||
name: "Fill bit masks",
|
||||
filledMask: "1111111111111111111111111111111111111111111111111111111111111111",
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
mask, _ := NewSocketMask()
|
||||
mask, _ := NewBitMask()
|
||||
mask.Fill()
|
||||
if mask.String() != string(tc.filledMask) {
|
||||
t.Errorf("Expected mask to be %v, got %v", tc.filledMask, mask)
|
||||
@ -204,7 +204,7 @@ func TestIsEmpty(t *testing.T) {
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
mask, _ := NewSocketMask(tc.maskBit)
|
||||
mask, _ := NewBitMask(tc.maskBit)
|
||||
empty := mask.IsEmpty()
|
||||
if empty {
|
||||
t.Errorf("Expected value to be %v, got %v", tc.expectedEmpty, empty)
|
||||
@ -225,7 +225,7 @@ func TestIsSet(t *testing.T) {
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
mask, _ := NewSocketMask(tc.maskBit)
|
||||
mask, _ := NewBitMask(tc.maskBit)
|
||||
set := mask.IsSet(tc.maskBit)
|
||||
if !set {
|
||||
t.Errorf("Expected value to be %v, got %v", tc.expectedSet, set)
|
||||
@ -241,15 +241,15 @@ func TestIsEqual(t *testing.T) {
|
||||
isEqual bool
|
||||
}{
|
||||
{
|
||||
name: "Check if two socket masks are equal",
|
||||
name: "Check if two bit masks are equal",
|
||||
firstMaskBit: 0,
|
||||
secondMaskBit: 0,
|
||||
isEqual: true,
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
firstMask, _ := NewSocketMask(tc.firstMaskBit)
|
||||
secondMask, _ := NewSocketMask(tc.secondMaskBit)
|
||||
firstMask, _ := NewBitMask(tc.firstMaskBit)
|
||||
secondMask, _ := NewBitMask(tc.secondMaskBit)
|
||||
isEqual := firstMask.IsEqual(secondMask)
|
||||
if !isEqual {
|
||||
t.Errorf("Expected mask to be %v, got %v", tc.isEqual, isEqual)
|
||||
@ -270,7 +270,7 @@ func TestCount(t *testing.T) {
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
mask, _ := NewSocketMask(tc.maskBit)
|
||||
mask, _ := NewBitMask(tc.maskBit)
|
||||
count := mask.Count()
|
||||
if count != tc.expectedCount {
|
||||
t.Errorf("Expected value to be %v, got %v", tc.expectedCount, count)
|
||||
@ -278,25 +278,25 @@ func TestCount(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetSockets(t *testing.T) {
|
||||
func TestGetBits(t *testing.T) {
|
||||
tcases := []struct {
|
||||
name string
|
||||
firstSocket int
|
||||
secondSocket int
|
||||
expectedSockets []int
|
||||
firstbit int
|
||||
secondbit int
|
||||
expectedbits []int
|
||||
}{
|
||||
{
|
||||
name: "Get number of each socket which has been set",
|
||||
firstSocket: 0,
|
||||
secondSocket: 1,
|
||||
expectedSockets: []int{0, 1},
|
||||
name: "Get number of each bit which has been set",
|
||||
firstbit: 0,
|
||||
secondbit: 1,
|
||||
expectedbits: []int{0, 1},
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
mask, _ := NewSocketMask(tc.firstSocket, tc.secondSocket)
|
||||
sockets := mask.GetSockets()
|
||||
if !reflect.DeepEqual(sockets, tc.expectedSockets) {
|
||||
t.Errorf("Expected value to be %v, got %v", tc.expectedSockets, sockets)
|
||||
mask, _ := NewBitMask(tc.firstbit, tc.secondbit)
|
||||
bits := mask.GetBits()
|
||||
if !reflect.DeepEqual(bits, tc.expectedbits) {
|
||||
t.Errorf("Expected value to be %v, got %v", tc.expectedbits, bits)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -334,8 +334,8 @@ func TestIsNarrowerThan(t *testing.T) {
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
firstMask, _ := NewSocketMask(tc.firstMask...)
|
||||
secondMask, _ := NewSocketMask(tc.secondMask...)
|
||||
firstMask, _ := NewBitMask(tc.firstMask...)
|
||||
secondMask, _ := NewBitMask(tc.secondMask...)
|
||||
expectedFirstNarrower := firstMask.IsNarrowerThan(secondMask)
|
||||
if expectedFirstNarrower != tc.expectedFirstNarrower {
|
||||
t.Errorf("Expected value to be %v, got %v", tc.expectedFirstNarrower, expectedFirstNarrower)
|
||||
@ -343,47 +343,47 @@ func TestIsNarrowerThan(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestIterateSocketMasks(t *testing.T) {
|
||||
func TestIterateBitMasks(t *testing.T) {
|
||||
tcases := []struct {
|
||||
name string
|
||||
numSockets int
|
||||
numbits int
|
||||
}{
|
||||
{
|
||||
name: "1 Socket",
|
||||
numSockets: 1,
|
||||
name: "1 bit",
|
||||
numbits: 1,
|
||||
},
|
||||
{
|
||||
name: "2 Sockets",
|
||||
numSockets: 2,
|
||||
name: "2 bits",
|
||||
numbits: 2,
|
||||
},
|
||||
{
|
||||
name: "4 Sockets",
|
||||
numSockets: 4,
|
||||
name: "4 bits",
|
||||
numbits: 4,
|
||||
},
|
||||
{
|
||||
name: "8 Sockets",
|
||||
numSockets: 8,
|
||||
name: "8 bits",
|
||||
numbits: 8,
|
||||
},
|
||||
{
|
||||
name: "16 Sockets",
|
||||
numSockets: 16,
|
||||
name: "16 bits",
|
||||
numbits: 16,
|
||||
},
|
||||
}
|
||||
for _, tc := range tcases {
|
||||
// Generate a list of sockets from tc.numSockets.
|
||||
var sockets []int
|
||||
for i := 0; i < tc.numSockets; i++ {
|
||||
sockets = append(sockets, i)
|
||||
// Generate a list of bits from tc.numbits.
|
||||
var bits []int
|
||||
for i := 0; i < tc.numbits; i++ {
|
||||
bits = append(bits, i)
|
||||
}
|
||||
|
||||
// Calculate the expected number of masks. Since we always have masks
|
||||
// with sockets from 0..n, this is just (2^n - 1) since we want 1 mask
|
||||
// with bits from 0..n, this is just (2^n - 1) since we want 1 mask
|
||||
// represented by each integer between 1 and 2^n-1.
|
||||
expectedNumMasks := (1 << uint(tc.numSockets)) - 1
|
||||
expectedNumMasks := (1 << uint(tc.numbits)) - 1
|
||||
|
||||
// Iterate all masks and count them.
|
||||
numMasks := 0
|
||||
IterateSocketMasks(sockets, func(SocketMask) {
|
||||
IterateBitMasks(bits, func(BitMask) {
|
||||
numMasks++
|
||||
})
|
||||
|
@ -33,12 +33,12 @@ func TestPolicySingleNumaNodeCanAdmitPodResult(t *testing.T) {
|
||||
},
|
||||
{
|
||||
name: "NUMANodeAffinity has multiple NUMA Nodes masked in topology hints",
|
||||
hint: TopologyHint{NewTestSocketMask(0, 1), true},
|
||||
hint: TopologyHint{NewTestBitMask(0, 1), true},
|
||||
expected: false,
|
||||
},
|
||||
{
|
||||
name: "NUMANodeAffinity has one NUMA Node masked in topology hints",
|
||||
hint: TopologyHint{NewTestSocketMask(0), true},
|
||||
hint: TopologyHint{NewTestBitMask(0), true},
|
||||
expected: true,
|
||||
},
|
||||
}
|
||||
|
@ -1,194 +0,0 @@
|
||||
/*
|
||||
Copyright 2019 The Kubernetes Authors.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
|
||||
package socketmask
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math/bits"
|
||||
)
|
||||
|
||||
// SocketMask interface allows hint providers to create SocketMasks for TopologyHints
|
||||
type SocketMask interface {
|
||||
Add(sockets ...int) error
|
||||
Remove(sockets ...int) error
|
||||
And(masks ...SocketMask)
|
||||
Or(masks ...SocketMask)
|
||||
Clear()
|
||||
Fill()
|
||||
IsEqual(mask SocketMask) bool
|
||||
IsEmpty() bool
|
||||
IsSet(socket int) bool
|
||||
IsNarrowerThan(mask SocketMask) bool
|
||||
String() string
|
||||
Count() int
|
||||
GetSockets() []int
|
||||
}
|
||||
|
||||
type socketMask uint64
|
||||
|
||||
// NewEmptySocketMask creates a new, empty SocketMask
|
||||
func NewEmptySocketMask() SocketMask {
|
||||
s := socketMask(0)
|
||||
return &s
|
||||
}
|
||||
|
||||
// NewSocketMask creates a new SocketMask
|
||||
func NewSocketMask(sockets ...int) (SocketMask, error) {
|
||||
s := socketMask(0)
|
||||
err := (&s).Add(sockets...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &s, nil
|
||||
}
|
||||
|
||||
// Add adds the sockets with topology affinity to the SocketMask
|
||||
func (s *socketMask) Add(sockets ...int) error {
|
||||
mask := *s
|
||||
for _, i := range sockets {
|
||||
if i < 0 || i >= 64 {
|
||||
return fmt.Errorf("socket number must be in range 0-63")
|
||||
}
|
||||
mask |= 1 << uint64(i)
|
||||
}
|
||||
*s = mask
|
||||
return nil
|
||||
}
|
||||
|
||||
// Remove removes specified sockets from SocketMask
|
||||
func (s *socketMask) Remove(sockets ...int) error {
|
||||
mask := *s
|
||||
for _, i := range sockets {
|
||||
if i < 0 || i >= 64 {
|
||||
return fmt.Errorf("socket number must be in range 0-63")
|
||||
}
|
||||
mask &^= 1 << uint64(i)
|
||||
}
|
||||
*s = mask
|
||||
return nil
|
||||
}
|
||||
|
||||
// And performs and operation on all bits in masks
|
||||
func (s *socketMask) And(masks ...SocketMask) {
|
||||
for _, m := range masks {
|
||||
*s &= *m.(*socketMask)
|
||||
}
|
||||
}
|
||||
|
||||
// Or performs or operation on all bits in masks
|
||||
func (s *socketMask) Or(masks ...SocketMask) {
|
||||
for _, m := range masks {
|
||||
*s |= *m.(*socketMask)
|
||||
}
|
||||
}
|
||||
|
||||
// Clear resets all bits in mask to zero
|
||||
func (s *socketMask) Clear() {
|
||||
*s = 0
|
||||
}
|
||||
|
||||
// Fill sets all bits in mask to one
|
||||
func (s *socketMask) Fill() {
|
||||
*s = socketMask(^uint64(0))
|
||||
}
|
||||
|
||||
// IsEmpty checks mask to see if all bits are zero
|
||||
func (s *socketMask) IsEmpty() bool {
|
||||
return *s == 0
|
||||
}
|
||||
|
||||
// IsSet checks socket in mask to see if bit is set to one
|
||||
func (s *socketMask) IsSet(socket int) bool {
|
||||
if socket < 0 || socket >= 64 {
|
||||
return false
|
||||
}
|
||||
return (*s & (1 << uint64(socket))) > 0
|
||||
}
|
||||
|
||||
// IsEqual checks if masks are equal
|
||||
func (s *socketMask) IsEqual(mask SocketMask) bool {
|
||||
return *s == *mask.(*socketMask)
|
||||
}
|
||||
|
||||
// IsNarrowerThan checks if one mask is narrower than another.
|
||||
//
|
||||
// A mask is said to be "narrower" than another if it has lets bits set. If the
|
||||
// same number of bits are set in both masks, then the mask with more
|
||||
// lower-numbered bits set wins out.
|
||||
func (s *socketMask) IsNarrowerThan(mask SocketMask) bool {
|
||||
if s.Count() == mask.Count() {
|
||||
if *s < *mask.(*socketMask) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return s.Count() < mask.Count()
|
||||
}
|
||||
|
||||
// String converts mask to string
|
||||
func (s *socketMask) String() string {
|
||||
return fmt.Sprintf("%064b", *s)
|
||||
}
|
||||
|
||||
// Count counts number of bits in mask set to one
|
||||
func (s *socketMask) Count() int {
|
||||
return bits.OnesCount64(uint64(*s))
|
||||
}
|
||||
|
||||
// GetSockets returns each socket number with bits set to one
|
||||
func (s *socketMask) GetSockets() []int {
|
||||
var sockets []int
|
||||
for i := uint64(0); i < 64; i++ {
|
||||
if (*s & (1 << i)) > 0 {
|
||||
sockets = append(sockets, int(i))
|
||||
}
|
||||
}
|
||||
return sockets
|
||||
}
|
||||
|
||||
// And is a package level implementation of 'and' between first and masks
|
||||
func And(first SocketMask, masks ...SocketMask) SocketMask {
|
||||
s := *first.(*socketMask)
|
||||
s.And(masks...)
|
||||
return &s
|
||||
}
|
||||
|
||||
// Or is a package level implementation of 'or' between first and masks
|
||||
func Or(first SocketMask, masks ...SocketMask) SocketMask {
|
||||
s := *first.(*socketMask)
|
||||
s.Or(masks...)
|
||||
return &s
|
||||
}
|
||||
|
||||
// IterateSocketMasks iterates all possible masks from a list of sockets,
|
||||
// issuing a callback on each mask.
|
||||
func IterateSocketMasks(sockets []int, callback func(SocketMask)) {
|
||||
var iterate func(sockets, accum []int, size int)
|
||||
iterate = func(sockets, accum []int, size int) {
|
||||
if len(accum) == size {
|
||||
mask, _ := NewSocketMask(accum...)
|
||||
callback(mask)
|
||||
return
|
||||
}
|
||||
for i := range sockets {
|
||||
iterate(sockets[i+1:], append(accum, sockets[i]), size)
|
||||
}
|
||||
}
|
||||
|
||||
for i := 1; i <= len(sockets); i++ {
|
||||
iterate(sockets, []int{}, i)
|
||||
}
|
||||
}
|
@ -22,7 +22,7 @@ import (
|
||||
"k8s.io/api/core/v1"
|
||||
"k8s.io/klog"
|
||||
cputopology "k8s.io/kubernetes/pkg/kubelet/cm/cpumanager/topology"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/socketmask"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/bitmask"
|
||||
"k8s.io/kubernetes/pkg/kubelet/lifecycle"
|
||||
)
|
||||
|
||||
@ -79,7 +79,7 @@ type Store interface {
|
||||
|
||||
//TopologyHint is a struct containing the NUMANodeAffinity for a Container
|
||||
type TopologyHint struct {
|
||||
NUMANodeAffinity socketmask.SocketMask
|
||||
NUMANodeAffinity bitmask.BitMask
|
||||
// Preferred is set to true when the NUMANodeAffinity encodes a preferred
|
||||
// allocation for the Container. It is set to false otherwise.
|
||||
Preferred bool
|
||||
@ -179,7 +179,7 @@ func (m *manager) iterateAllProviderTopologyHints(allProviderHints [][]TopologyH
|
||||
func (m *manager) calculateAffinity(pod v1.Pod, container v1.Container) TopologyHint {
|
||||
// Set the default affinity as an any-numa affinity containing the list
|
||||
// of NUMA Nodes available on this machine.
|
||||
defaultAffinity, _ := socketmask.NewSocketMask(m.numaNodes...)
|
||||
defaultAffinity, _ := bitmask.NewBitMask(m.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
|
||||
@ -224,7 +224,7 @@ func (m *manager) calculateAffinity(pod v1.Pod, container v1.Container) Topology
|
||||
// Get the NUMANodeAffinity from each hint in the permutation and see if any
|
||||
// of them encode unpreferred allocations.
|
||||
preferred := true
|
||||
var numaAffinities []socketmask.SocketMask
|
||||
var numaAffinities []bitmask.BitMask
|
||||
for _, hint := range permutation {
|
||||
// Only consider hints that have an actual NUMANodeAffinity set.
|
||||
if hint.NUMANodeAffinity != nil {
|
||||
@ -241,7 +241,7 @@ func (m *manager) calculateAffinity(pod v1.Pod, container v1.Container) Topology
|
||||
}
|
||||
|
||||
// Merge the affinities using a bitwise-and operation.
|
||||
mergedAffinity, _ := socketmask.NewSocketMask(m.numaNodes...)
|
||||
mergedAffinity, _ := bitmask.NewBitMask(m.numaNodes...)
|
||||
mergedAffinity.And(numaAffinities...)
|
||||
|
||||
// Build a mergedHintfrom the merged affinity mask, indicating if an
|
||||
|
@ -24,12 +24,12 @@ import (
|
||||
|
||||
"k8s.io/api/core/v1"
|
||||
"k8s.io/apimachinery/pkg/types"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/socketmask"
|
||||
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/bitmask"
|
||||
"k8s.io/kubernetes/pkg/kubelet/lifecycle"
|
||||
)
|
||||
|
||||
func NewTestSocketMask(sockets ...int) socketmask.SocketMask {
|
||||
s, _ := socketmask.NewSocketMask(sockets...)
|
||||
func NewTestBitMask(sockets ...int) bitmask.BitMask {
|
||||
s, _ := bitmask.NewBitMask(sockets...)
|
||||
return s
|
||||
}
|
||||
|
||||
@ -117,7 +117,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
name: "TopologyHint not set",
|
||||
hp: []HintProvider{},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(numaNodes...),
|
||||
NUMANodeAffinity: NewTestBitMask(numaNodes...),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -129,7 +129,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(numaNodes...),
|
||||
NUMANodeAffinity: NewTestBitMask(numaNodes...),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -143,7 +143,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(numaNodes...),
|
||||
NUMANodeAffinity: NewTestBitMask(numaNodes...),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -157,7 +157,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(numaNodes...),
|
||||
NUMANodeAffinity: NewTestBitMask(numaNodes...),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
@ -176,7 +176,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(numaNodes...),
|
||||
NUMANodeAffinity: NewTestBitMask(numaNodes...),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -195,7 +195,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(numaNodes...),
|
||||
NUMANodeAffinity: NewTestBitMask(numaNodes...),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -206,7 +206,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource1": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -216,7 +216,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource2": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -224,7 +224,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -235,7 +235,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource1": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -245,7 +245,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource2": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -253,7 +253,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -264,7 +264,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource1": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -274,7 +274,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource2": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0, 1),
|
||||
NUMANodeAffinity: NewTestBitMask(0, 1),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -282,7 +282,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -293,7 +293,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource1": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -303,7 +303,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource2": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0, 1),
|
||||
NUMANodeAffinity: NewTestBitMask(0, 1),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -311,7 +311,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -322,7 +322,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource1": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -332,7 +332,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource2": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -340,7 +340,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(numaNodes...),
|
||||
NUMANodeAffinity: NewTestBitMask(numaNodes...),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
@ -351,7 +351,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource1": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -361,7 +361,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource2": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
@ -369,7 +369,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
@ -380,7 +380,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource1": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -390,7 +390,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource2": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
@ -398,7 +398,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
@ -410,7 +410,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -418,7 +418,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -430,7 +430,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -438,7 +438,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -449,11 +449,11 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource1": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -463,7 +463,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource2": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -471,7 +471,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -482,11 +482,11 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource1": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -496,7 +496,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource2": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -504,7 +504,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -515,11 +515,11 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource1": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -529,7 +529,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource2": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0, 1),
|
||||
NUMANodeAffinity: NewTestBitMask(0, 1),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
@ -537,7 +537,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
@ -548,11 +548,11 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource1": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -562,11 +562,11 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource2": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0, 1),
|
||||
NUMANodeAffinity: NewTestBitMask(0, 1),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
@ -574,7 +574,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -585,11 +585,11 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource1": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0, 1),
|
||||
NUMANodeAffinity: NewTestBitMask(0, 1),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
@ -599,15 +599,15 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource2": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0, 1),
|
||||
NUMANodeAffinity: NewTestBitMask(0, 1),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
@ -615,7 +615,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -626,25 +626,25 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource1": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0, 1),
|
||||
NUMANodeAffinity: NewTestBitMask(0, 1),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
"resource2": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0, 1),
|
||||
NUMANodeAffinity: NewTestBitMask(0, 1),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
@ -652,7 +652,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
@ -664,21 +664,21 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource1": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0, 1),
|
||||
NUMANodeAffinity: NewTestBitMask(0, 1),
|
||||
Preferred: true,
|
||||
},
|
||||
},
|
||||
"resource2": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0, 1),
|
||||
NUMANodeAffinity: NewTestBitMask(0, 1),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
@ -686,7 +686,7 @@ func TestCalculateAffinity(t *testing.T) {
|
||||
},
|
||||
},
|
||||
expected: TopologyHint{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
@ -835,11 +835,11 @@ func TestAdmit(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0, 1),
|
||||
NUMANodeAffinity: NewTestBitMask(0, 1),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
@ -857,15 +857,15 @@ func TestAdmit(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0, 1),
|
||||
NUMANodeAffinity: NewTestBitMask(0, 1),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
@ -883,7 +883,7 @@ func TestAdmit(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0, 1),
|
||||
NUMANodeAffinity: NewTestBitMask(0, 1),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
@ -901,11 +901,11 @@ func TestAdmit(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0, 1),
|
||||
NUMANodeAffinity: NewTestBitMask(0, 1),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
@ -923,15 +923,15 @@ func TestAdmit(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0),
|
||||
NUMANodeAffinity: NewTestBitMask(0),
|
||||
Preferred: true,
|
||||
},
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(1),
|
||||
NUMANodeAffinity: NewTestBitMask(1),
|
||||
Preferred: true,
|
||||
},
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0, 1),
|
||||
NUMANodeAffinity: NewTestBitMask(0, 1),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
@ -949,7 +949,7 @@ func TestAdmit(t *testing.T) {
|
||||
map[string][]TopologyHint{
|
||||
"resource": {
|
||||
{
|
||||
NUMANodeAffinity: NewTestSocketMask(0, 1),
|
||||
NUMANodeAffinity: NewTestBitMask(0, 1),
|
||||
Preferred: false,
|
||||
},
|
||||
},
|
||||
|
Loading…
Reference in New Issue
Block a user