diff --git a/pkg/kubelet/cm/cpumanager/BUILD b/pkg/kubelet/cm/cpumanager/BUILD index 24cf06638f0..93ba44e4f85 100644 --- a/pkg/kubelet/cm/cpumanager/BUILD +++ b/pkg/kubelet/cm/cpumanager/BUILD @@ -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", diff --git a/pkg/kubelet/cm/cpumanager/policy_static.go b/pkg/kubelet/cm/cpumanager/policy_static.go index 8789f6e23ae..241f14463a8 100644 --- a/pkg/kubelet/cm/cpumanager/policy_static.go +++ b/pkg/kubelet/cm/cpumanager/policy_static.go @@ -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))) } diff --git a/pkg/kubelet/cm/cpumanager/policy_static_test.go b/pkg/kubelet/cm/cpumanager/policy_static_test.go index 17847eb0243..3d30009917a 100644 --- a/pkg/kubelet/cm/cpumanager/policy_static_test.go +++ b/pkg/kubelet/cm/cpumanager/policy_static_test.go @@ -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), diff --git a/pkg/kubelet/cm/cpumanager/topology_hints.go b/pkg/kubelet/cm/cpumanager/topology_hints.go index ce70c5465f5..1648b7678d3 100644 --- a/pkg/kubelet/cm/cpumanager/topology_hints.go +++ b/pkg/kubelet/cm/cpumanager/topology_hints.go @@ -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 diff --git a/pkg/kubelet/cm/cpumanager/topology_hints_test.go b/pkg/kubelet/cm/cpumanager/topology_hints_test.go index e9102892a23..3f0be9a6388 100644 --- a/pkg/kubelet/cm/cpumanager/topology_hints_test.go +++ b/pkg/kubelet/cm/cpumanager/topology_hints_test.go @@ -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, diff --git a/pkg/kubelet/cm/devicemanager/BUILD b/pkg/kubelet/cm/devicemanager/BUILD index ee0ca125a95..4bbdbc2068f 100644 --- a/pkg/kubelet/cm/devicemanager/BUILD +++ b/pkg/kubelet/cm/devicemanager/BUILD @@ -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", diff --git a/pkg/kubelet/cm/devicemanager/manager.go b/pkg/kubelet/cm/devicemanager/manager.go index 053ec621618..12a5c6da900 100644 --- a/pkg/kubelet/cm/devicemanager/manager.go +++ b/pkg/kubelet/cm/devicemanager/manager.go @@ -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 diff --git a/pkg/kubelet/cm/devicemanager/topology_hints.go b/pkg/kubelet/cm/devicemanager/topology_hints.go index 38ae0e166f7..8fbeff4858a 100644 --- a/pkg/kubelet/cm/devicemanager/topology_hints.go +++ b/pkg/kubelet/cm/devicemanager/topology_hints.go @@ -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] { diff --git a/pkg/kubelet/cm/devicemanager/topology_hints_test.go b/pkg/kubelet/cm/devicemanager/topology_hints_test.go index d6c0638679e..55179dab967 100644 --- a/pkg/kubelet/cm/devicemanager/topology_hints_test.go +++ b/pkg/kubelet/cm/devicemanager/topology_hints_test.go @@ -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 } diff --git a/pkg/kubelet/cm/topologymanager/BUILD b/pkg/kubelet/cm/topologymanager/BUILD index d69ba9ba597..c0dd4d1249e 100644 --- a/pkg/kubelet/cm/topologymanager/BUILD +++ b/pkg/kubelet/cm/topologymanager/BUILD @@ -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", diff --git a/pkg/kubelet/cm/topologymanager/socketmask/BUILD b/pkg/kubelet/cm/topologymanager/bitmask/BUILD similarity index 87% rename from pkg/kubelet/cm/topologymanager/socketmask/BUILD rename to pkg/kubelet/cm/topologymanager/bitmask/BUILD index 25bd381e862..8d89cfe4751 100644 --- a/pkg/kubelet/cm/topologymanager/socketmask/BUILD +++ b/pkg/kubelet/cm/topologymanager/bitmask/BUILD @@ -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"], ) diff --git a/pkg/kubelet/cm/topologymanager/bitmask/bitmask.go b/pkg/kubelet/cm/topologymanager/bitmask/bitmask.go new file mode 100644 index 00000000000..0f01da319a3 --- /dev/null +++ b/pkg/kubelet/cm/topologymanager/bitmask/bitmask.go @@ -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) + } +} diff --git a/pkg/kubelet/cm/topologymanager/socketmask/socketmask_test.go b/pkg/kubelet/cm/topologymanager/bitmask/bitmask_test.go similarity index 71% rename from pkg/kubelet/cm/topologymanager/socketmask/socketmask_test.go rename to pkg/kubelet/cm/topologymanager/bitmask/bitmask_test.go index 38424890896..a17af150c7e 100644 --- a/pkg/kubelet/cm/topologymanager/socketmask/socketmask_test.go +++ b/pkg/kubelet/cm/topologymanager/bitmask/bitmask_test.go @@ -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) } @@ -66,23 +66,23 @@ func TestAdd(t *testing.T) { func TestRemove(t *testing.T) { tcases := []struct { - name string - firstSocketSet int - secondSocketSet int - firstSocketRemove int - expectedMask string + name string + firstbitset int + secondbitset int + firstbitRemove int + expectedMask string }{ { - name: "Reset bit 1 SocketMask to 0", - firstSocketSet: 0, - secondSocketSet: 1, - firstSocketRemove: 0, - expectedMask: "0000000000000000000000000000000000000000000000000000000000000010", + 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 + name string + 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 + name string + 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++ }) 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 88cec2977b0..7525b99949c 100644 --- a/pkg/kubelet/cm/topologymanager/policy_single_numa_node_test.go +++ b/pkg/kubelet/cm/topologymanager/policy_single_numa_node_test.go @@ -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, }, } diff --git a/pkg/kubelet/cm/topologymanager/socketmask/socketmask.go b/pkg/kubelet/cm/topologymanager/socketmask/socketmask.go deleted file mode 100644 index 8befaec0bce..00000000000 --- a/pkg/kubelet/cm/topologymanager/socketmask/socketmask.go +++ /dev/null @@ -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) - } -} diff --git a/pkg/kubelet/cm/topologymanager/topology_manager.go b/pkg/kubelet/cm/topologymanager/topology_manager.go index ab54b9be4ce..5c25a183b92 100644 --- a/pkg/kubelet/cm/topologymanager/topology_manager.go +++ b/pkg/kubelet/cm/topologymanager/topology_manager.go @@ -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 diff --git a/pkg/kubelet/cm/topologymanager/topology_manager_test.go b/pkg/kubelet/cm/topologymanager/topology_manager_test.go index 83e1fd49edd..ecec3e71b33 100644 --- a/pkg/kubelet/cm/topologymanager/topology_manager_test.go +++ b/pkg/kubelet/cm/topologymanager/topology_manager_test.go @@ -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, }, },