github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-23 19:56:01 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #83033 from ConnorDoyle/rename-socketmask

Browse Source 
Rename package socketmask to bitmask.
This commit is contained in:
Kubernetes Prow Robot 2019-09-24 00:26:02 -07:00 committed by GitHub
commit 4e63af2324
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 404 additions and 404 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
pkg/kubelet/cm/cpumanager/BUILD
View File

@ -20,7 +20,7 @@ go_library(
"//pkg/kubelet/cm/cpumanager/topology:go_default_library", "//pkg/kubelet/cm/cpumanager/topology:go_default_library",
"//pkg/kubelet/cm/cpuset:go_default_library", "//pkg/kubelet/cm/cpuset:go_default_library",
"//pkg/kubelet/cm/topologymanager: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/container:go_default_library",
"//pkg/kubelet/status:go_default_library", "//pkg/kubelet/status:go_default_library",
"//staging/src/k8s.io/api/core/v1: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/cpumanager/topology:go_default_library",
"//pkg/kubelet/cm/cpuset:go_default_library", "//pkg/kubelet/cm/cpuset:go_default_library",
"//pkg/kubelet/cm/topologymanager: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/api/core/v1:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/api/resource: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", "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",

6
pkg/kubelet/cm/cpumanager/policy_static.go
View File

@ -26,7 +26,7 @@ import (
"k8s.io/kubernetes/pkg/kubelet/cm/cpumanager/topology" "k8s.io/kubernetes/pkg/kubelet/cm/cpumanager/topology"
"k8s.io/kubernetes/pkg/kubelet/cm/cpuset" "k8s.io/kubernetes/pkg/kubelet/cm/cpuset"
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager" "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 // PolicyStatic is the name of the static policy
@ -250,14 +250,14 @@ func (p *staticPolicy) RemoveContainer(s state.State, containerID string) (rerr
return nil 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) klog.Infof("[cpumanager] allocateCpus: (numCPUs: %d, socket: %v)", numCPUs, numaAffinity)
// If there are aligned CPUs in numaAffinity, attempt to take those first. // If there are aligned CPUs in numaAffinity, attempt to take those first.
result := cpuset.NewCPUSet() result := cpuset.NewCPUSet()
if numaAffinity != nil { if numaAffinity != nil {
alignedCPUs := cpuset.NewCPUSet() 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))) alignedCPUs = alignedCPUs.Union(p.assignableCPUs(s).Intersection(p.topology.CPUDetails.CPUsInNUMANodes(numaNodeID)))
} }

30
pkg/kubelet/cm/cpumanager/policy_static_test.go
View File

@ -26,7 +26,7 @@ import (
"k8s.io/kubernetes/pkg/kubelet/cm/cpumanager/topology" "k8s.io/kubernetes/pkg/kubelet/cm/cpumanager/topology"
"k8s.io/kubernetes/pkg/kubelet/cm/cpuset" "k8s.io/kubernetes/pkg/kubelet/cm/cpuset"
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager" "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 { type staticPolicyTest struct {
@ -746,11 +746,11 @@ func TestTopologyAwareAllocateCPUs(t *testing.T) {
stAssignments state.ContainerCPUAssignments stAssignments state.ContainerCPUAssignments
stDefaultCPUSet cpuset.CPUSet stDefaultCPUSet cpuset.CPUSet
numRequested int numRequested int
socketMask socketmask.SocketMask socketMask bitmask.BitMask
expCSet cpuset.CPUSet expCSet cpuset.CPUSet
}{ }{
{ {
description: "Request 2 CPUs, No SocketMask", description: "Request 2 CPUs, No BitMask",
topo: topoDualSocketHT, topo: topoDualSocketHT,
stAssignments: state.ContainerCPUAssignments{}, stAssignments: state.ContainerCPUAssignments{},
stDefaultCPUSet: cpuset.NewCPUSet(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11), 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), expCSet: cpuset.NewCPUSet(0, 6),
}, },
{ {
description: "Request 2 CPUs, SocketMask on Socket 0", description: "Request 2 CPUs, BitMask on Socket 0",
topo: topoDualSocketHT, topo: topoDualSocketHT,
stAssignments: state.ContainerCPUAssignments{}, stAssignments: state.ContainerCPUAssignments{},
stDefaultCPUSet: cpuset.NewCPUSet(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11), stDefaultCPUSet: cpuset.NewCPUSet(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11),
numRequested: 2, numRequested: 2,
socketMask: func() socketmask.SocketMask { socketMask: func() bitmask.BitMask {
mask, _ := socketmask.NewSocketMask(0) mask, _ := bitmask.NewBitMask(0)
return mask return mask
}(), }(),
expCSet: cpuset.NewCPUSet(0, 6), expCSet: cpuset.NewCPUSet(0, 6),
}, },
{ {
description: "Request 2 CPUs, SocketMask on Socket 1", description: "Request 2 CPUs, BitMask on Socket 1",
topo: topoDualSocketHT, topo: topoDualSocketHT,
stAssignments: state.ContainerCPUAssignments{}, stAssignments: state.ContainerCPUAssignments{},
stDefaultCPUSet: cpuset.NewCPUSet(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11), stDefaultCPUSet: cpuset.NewCPUSet(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11),
numRequested: 2, numRequested: 2,
socketMask: func() socketmask.SocketMask { socketMask: func() bitmask.BitMask {
mask, _ := socketmask.NewSocketMask(1) mask, _ := bitmask.NewBitMask(1)
return mask return mask
}(), }(),
expCSet: cpuset.NewCPUSet(1, 7), expCSet: cpuset.NewCPUSet(1, 7),
}, },
{ {
description: "Request 8 CPUs, SocketMask on Socket 0", description: "Request 8 CPUs, BitMask on Socket 0",
topo: topoDualSocketHT, topo: topoDualSocketHT,
stAssignments: state.ContainerCPUAssignments{}, stAssignments: state.ContainerCPUAssignments{},
stDefaultCPUSet: cpuset.NewCPUSet(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11), stDefaultCPUSet: cpuset.NewCPUSet(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11),
numRequested: 8, numRequested: 8,
socketMask: func() socketmask.SocketMask { socketMask: func() bitmask.BitMask {
mask, _ := socketmask.NewSocketMask(0) mask, _ := bitmask.NewBitMask(0)
return mask return mask
}(), }(),
expCSet: cpuset.NewCPUSet(0, 6, 2, 8, 4, 10, 1, 7), 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, topo: topoDualSocketHT,
stAssignments: state.ContainerCPUAssignments{}, stAssignments: state.ContainerCPUAssignments{},
stDefaultCPUSet: cpuset.NewCPUSet(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11), stDefaultCPUSet: cpuset.NewCPUSet(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11),
numRequested: 8, numRequested: 8,
socketMask: func() socketmask.SocketMask { socketMask: func() bitmask.BitMask {
mask, _ := socketmask.NewSocketMask(1) mask, _ := bitmask.NewBitMask(1)
return mask return mask
}(), }(),
expCSet: cpuset.NewCPUSet(1, 7, 3, 9, 5, 11, 0, 6), expCSet: cpuset.NewCPUSet(1, 7, 3, 9, 5, 11, 0, 6),

16
pkg/kubelet/cm/cpumanager/topology_hints.go
View File

@ -22,7 +22,7 @@ import (
"k8s.io/kubernetes/pkg/kubelet/cm/cpuset" "k8s.io/kubernetes/pkg/kubelet/cm/cpuset"
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager" "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 { 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. // Initialize minSocketsOnMinAffinity to include all Sockets.
minSocketsOnMinAffinity := m.topology.CPUDetails.Sockets().Size() 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{} 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 // First, update minAffinitySize and minSocketsOnMinAffinity for the
// current request size. // current request size.
cpusInMask := m.topology.CPUDetails.CPUsInNUMANodes(mask.GetSockets()...).Size() cpusInMask := m.topology.CPUDetails.CPUsInNUMANodes(mask.GetBits()...).Size()
socketsInMask := m.topology.CPUDetails.SocketsInNUMANodes(mask.GetSockets()...).Size() socketsInMask := m.topology.CPUDetails.SocketsInNUMANodes(mask.GetBits()...).Size()
if cpusInMask >= request && mask.Count() < minAffinitySize { if cpusInMask >= request && mask.Count() < minAffinitySize {
minAffinitySize = mask.Count() minAffinitySize = mask.Count()
if socketsInMask < minSocketsOnMinAffinity { 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 // 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 numMatching := 0
for _, c := range availableCPUs.ToSlice() { for _, c := range availableCPUs.ToSlice() {
if mask.IsSet(m.topology.CPUDetails[c].NUMANodeID) { if mask.IsSet(m.topology.CPUDetails[c].NUMANodeID) {
@ -104,7 +104,7 @@ func (m *manager) generateCPUTopologyHints(availableCPUs cpuset.CPUSet, request
return 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 // list of hints. We set all hint preferences to 'false' on the first
// pass through. // pass through.
hints = append(hints, topologymanager.TopologyHint{ 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. // with a minimal set of sockets) will be considered preferred.
for i := range hints { for i := range hints {
if hints[i].NUMANodeAffinity.Count() == minAffinitySize { if hints[i].NUMANodeAffinity.Count() == minAffinitySize {
nodes := hints[i].NUMANodeAffinity.GetSockets() nodes := hints[i].NUMANodeAffinity.GetBits()
numSockets := m.topology.CPUDetails.SocketsInNUMANodes(nodes...).Size() numSockets := m.topology.CPUDetails.SocketsInNUMANodes(nodes...).Size()
if numSockets == minSocketsOnMinAffinity { if numSockets == minSocketsOnMinAffinity {
hints[i].Preferred = true hints[i].Preferred = true

8
pkg/kubelet/cm/cpumanager/topology_hints_test.go
View File

@ -26,7 +26,7 @@ import (
"k8s.io/kubernetes/pkg/kubelet/cm/cpumanager/topology" "k8s.io/kubernetes/pkg/kubelet/cm/cpumanager/topology"
"k8s.io/kubernetes/pkg/kubelet/cm/cpuset" "k8s.io/kubernetes/pkg/kubelet/cm/cpuset"
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager" "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 { func topologyHintLessThan(a topologymanager.TopologyHint, b topologymanager.TopologyHint) bool {
@ -46,9 +46,9 @@ func TestGetTopologyHints(t *testing.T) {
testPod4 := makePod("11", "11") testPod4 := makePod("11", "11")
testContainer4 := &testPod4.Spec.Containers[0] testContainer4 := &testPod4.Spec.Containers[0]
firstSocketMask, _ := socketmask.NewSocketMask(0) firstSocketMask, _ := bitmask.NewBitMask(0)
secondSocketMask, _ := socketmask.NewSocketMask(1) secondSocketMask, _ := bitmask.NewBitMask(1)
crossSocketMask, _ := socketmask.NewSocketMask(0, 1) crossSocketMask, _ := bitmask.NewBitMask(0, 1)
machineInfo := cadvisorapi.MachineInfo{ machineInfo := cadvisorapi.MachineInfo{
NumCores: 12, NumCores: 12,

4
pkg/kubelet/cm/devicemanager/BUILD
View File

@ -24,7 +24,7 @@ go_library(
"//pkg/kubelet/cm/cpumanager/topology:go_default_library", "//pkg/kubelet/cm/cpumanager/topology:go_default_library",
"//pkg/kubelet/cm/devicemanager/checkpoint:go_default_library", "//pkg/kubelet/cm/devicemanager/checkpoint:go_default_library",
"//pkg/kubelet/cm/topologymanager: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/config:go_default_library",
"//pkg/kubelet/container:go_default_library", "//pkg/kubelet/container:go_default_library",
"//pkg/kubelet/lifecycle: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/apis/pluginregistration/v1:go_default_library",
"//pkg/kubelet/checkpointmanager:go_default_library", "//pkg/kubelet/checkpointmanager:go_default_library",
"//pkg/kubelet/cm/topologymanager: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/config:go_default_library",
"//pkg/kubelet/lifecycle:go_default_library", "//pkg/kubelet/lifecycle:go_default_library",
"//pkg/kubelet/pluginmanager:go_default_library", "//pkg/kubelet/pluginmanager:go_default_library",

4
pkg/kubelet/cm/devicemanager/manager.go
View File

@ -42,7 +42,7 @@ import (
cputopology "k8s.io/kubernetes/pkg/kubelet/cm/cpumanager/topology" cputopology "k8s.io/kubernetes/pkg/kubelet/cm/cpumanager/topology"
"k8s.io/kubernetes/pkg/kubelet/cm/devicemanager/checkpoint" "k8s.io/kubernetes/pkg/kubelet/cm/devicemanager/checkpoint"
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager" "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/config"
"k8s.io/kubernetes/pkg/kubelet/lifecycle" "k8s.io/kubernetes/pkg/kubelet/lifecycle"
"k8s.io/kubernetes/pkg/kubelet/metrics" "k8s.io/kubernetes/pkg/kubelet/metrics"
@ -674,7 +674,7 @@ func (m *ManagerImpl) devicesToAllocate(podUID, contName, resource string, requi
return devices, nil 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 // 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 // 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 // available device does not have any NUMA Nodes associated with it, add it

4
pkg/kubelet/cm/devicemanager/topology_hints.go
View File

@ -21,7 +21,7 @@ import (
"k8s.io/apimachinery/pkg/util/sets" "k8s.io/apimachinery/pkg/util/sets"
"k8s.io/klog" "k8s.io/klog"
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager" "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 // 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. // Iterate through all combinations of NUMA Nodes and build hints from them.
hints := []topologymanager.TopologyHint{} 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. // First, update minAffinitySize for the current request size.
devicesInMask := 0 devicesInMask := 0
for _, device := range m.allDevices[resource] { for _, device := range m.allDevices[resource] {

6
pkg/kubelet/cm/devicemanager/topology_hints_test.go
View File

@ -26,7 +26,7 @@ import (
"k8s.io/apimachinery/pkg/util/sets" "k8s.io/apimachinery/pkg/util/sets"
pluginapi "k8s.io/kubernetes/pkg/kubelet/apis/deviceplugin/v1beta1" pluginapi "k8s.io/kubernetes/pkg/kubelet/apis/deviceplugin/v1beta1"
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager" "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 { type mockAffinityStore struct {
@ -51,8 +51,8 @@ func topologyHintLessThan(a topologymanager.TopologyHint, b topologymanager.Topo
return a.NUMANodeAffinity.IsNarrowerThan(b.NUMANodeAffinity) return a.NUMANodeAffinity.IsNarrowerThan(b.NUMANodeAffinity)
} }
func makeSocketMask(sockets ...int) socketmask.SocketMask { func makeSocketMask(sockets ...int) bitmask.BitMask {
mask, _ := socketmask.NewSocketMask(sockets...) mask, _ := bitmask.NewBitMask(sockets...)
return mask return mask
} }

6
pkg/kubelet/cm/topologymanager/BUILD
View File

@ -15,7 +15,7 @@ go_library(
visibility = ["//visibility:public"], visibility = ["//visibility:public"],
deps = [ deps = [
"//pkg/kubelet/cm/cpumanager/topology:go_default_library", "//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", "//pkg/kubelet/lifecycle:go_default_library",
"//staging/src/k8s.io/api/core/v1:go_default_library", "//staging/src/k8s.io/api/core/v1:go_default_library",
"//vendor/k8s.io/klog:go_default_library", "//vendor/k8s.io/klog:go_default_library",
@ -33,7 +33,7 @@ filegroup(
name = "all-srcs", name = "all-srcs",
srcs = [ srcs = [
":package-srcs", ":package-srcs",
"//pkg/kubelet/cm/topologymanager/socketmask:all-srcs", "//pkg/kubelet/cm/topologymanager/bitmask:all-srcs",
], ],
tags = ["automanaged"], tags = ["automanaged"],
visibility = ["//visibility:public"], visibility = ["//visibility:public"],
@ -51,7 +51,7 @@ go_test(
], ],
embed = [":go_default_library"], embed = [":go_default_library"],
deps = [ deps = [
"//pkg/kubelet/cm/topologymanager/socketmask:go_default_library", "//pkg/kubelet/cm/topologymanager/bitmask:go_default_library",
"//pkg/kubelet/lifecycle:go_default_library", "//pkg/kubelet/lifecycle:go_default_library",
"//staging/src/k8s.io/api/core/v1:go_default_library", "//staging/src/k8s.io/api/core/v1:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/types:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/types:go_default_library",

6
pkg/kubelet/cm/topologymanager/socketmask/BUILD → pkg/kubelet/cm/topologymanager/bitmask/BUILD
View File

@ -2,8 +2,8 @@ load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
go_library( go_library(
name = "go_default_library", name = "go_default_library",
srcs = ["socketmask.go"], srcs = ["bitmask.go"],
importpath = "k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/socketmask", importpath = "k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/bitmask",
visibility = ["//visibility:public"], visibility = ["//visibility:public"],
) )
@ -23,6 +23,6 @@ filegroup(
go_test( go_test(
name = "go_default_test", name = "go_default_test",
srcs = ["socketmask_test.go"], srcs = ["bitmask_test.go"],
embed = [":go_default_library"], embed = [":go_default_library"],
) )

194
pkg/kubelet/cm/topologymanager/bitmask/bitmask.go Normal file
View 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)
}
}

152
pkg/kubelet/cm/topologymanager/socketmask/socketmask_test.go → pkg/kubelet/cm/topologymanager/bitmask/bitmask_test.go
View File

@ -14,27 +14,27 @@ See the License for the specific language governing permissions and
limitations under the License. limitations under the License.
*/ */
package socketmask package bitmask
import ( import (
"reflect" "reflect"
"testing" "testing"
) )
func TestNewSocketMask(t *testing.T) { func TestNewBitMask(t *testing.T) {
tcases := []struct { tcases := []struct {
name string name string
socket int bit int
expectedMask string expectedMask string
}{ }{
{ {
name: "New SocketMask with socket 0 set", name: "New BitMask with bit 0 set",
socket: 0, bit: 0,
expectedMask: "0000000000000000000000000000000000000000000000000000000000000001", expectedMask: "0000000000000000000000000000000000000000000000000000000000000001",
}, },
} }
for _, tc := range tcases { for _, tc := range tcases {
sm, _ := NewSocketMask(0) sm, _ := NewBitMask(0)
if sm.String() != tc.expectedMask { if sm.String() != tc.expectedMask {
t.Errorf("Expected mask to be %v, got %v", tc.expectedMask, sm) 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) { func TestAdd(t *testing.T) {
tcases := []struct { tcases := []struct {
name string name string
firstSocket int firstbit int
secondSocket int secondbit int
expectedMask string expectedMask string
}{ }{
{ {
name: "New SocketMask with sockets 0 and 1 set", name: "New BitMask with bits 0 and 1 set",
firstSocket: 0, firstbit: 0,
secondSocket: 1, secondbit: 1,
expectedMask: "0000000000000000000000000000000000000000000000000000000000000011", expectedMask: "0000000000000000000000000000000000000000000000000000000000000011",
}, },
} }
for _, tc := range tcases { for _, tc := range tcases {
mask, _ := NewSocketMask() mask, _ := NewBitMask()
mask.Add(tc.firstSocket, tc.secondSocket) mask.Add(tc.firstbit, tc.secondbit)
if mask.String() != tc.expectedMask { if mask.String() != tc.expectedMask {
t.Errorf("Expected mask to be %v, got %v", tc.expectedMask, mask) 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) { func TestRemove(t *testing.T) {
tcases := []struct { tcases := []struct {
name string name string
firstSocketSet int firstbitset int
secondSocketSet int secondbitset int
firstSocketRemove int firstbitRemove int
expectedMask string expectedMask string
}{ }{
{ {
name: "Reset bit 1 SocketMask to 0", name: "Reset bit 1 BitMask to 0",
firstSocketSet: 0, firstbitset: 0,
secondSocketSet: 1, secondbitset: 1,
firstSocketRemove: 0, firstbitRemove: 0,
expectedMask: "0000000000000000000000000000000000000000000000000000000000000010", expectedMask: "0000000000000000000000000000000000000000000000000000000000000010",
}, },
} }
for _, tc := range tcases { for _, tc := range tcases {
mask, _ := NewSocketMask(tc.firstSocketSet, tc.secondSocketSet) mask, _ := NewBitMask(tc.firstbitset, tc.secondbitset)
mask.Remove(tc.firstSocketRemove) mask.Remove(tc.firstbitRemove)
if mask.String() != tc.expectedMask { if mask.String() != tc.expectedMask {
t.Errorf("Expected mask to be %v, got %v", tc.expectedMask, mask) t.Errorf("Expected mask to be %v, got %v", tc.expectedMask, mask)
} }
@ -97,15 +97,15 @@ func TestAnd(t *testing.T) {
andMask string andMask string
}{ }{
{ {
name: "And socket masks", name: "And bit masks",
firstMaskBit: 0, firstMaskBit: 0,
secondMaskBit: 0, secondMaskBit: 0,
andMask: "0000000000000000000000000000000000000000000000000000000000000001", andMask: "0000000000000000000000000000000000000000000000000000000000000001",
}, },
} }
for _, tc := range tcases { for _, tc := range tcases {
firstMask, _ := NewSocketMask(tc.firstMaskBit) firstMask, _ := NewBitMask(tc.firstMaskBit)
secondMask, _ := NewSocketMask(tc.secondMaskBit) secondMask, _ := NewBitMask(tc.secondMaskBit)
result := And(firstMask, secondMask) result := And(firstMask, secondMask)
if result.String() != string(tc.andMask) { if result.String() != string(tc.andMask) {
@ -127,15 +127,15 @@ func TestOr(t *testing.T) {
orMask string orMask string
}{ }{
{ {
name: "Or socket masks", name: "Or bit masks",
firstMaskBit: 0, firstMaskBit: 0,
secondMaskBit: 1, secondMaskBit: 1,
orMask: "0000000000000000000000000000000000000000000000000000000000000011", orMask: "0000000000000000000000000000000000000000000000000000000000000011",
}, },
} }
for _, tc := range tcases { for _, tc := range tcases {
firstMask, _ := NewSocketMask(tc.firstMaskBit) firstMask, _ := NewBitMask(tc.firstMaskBit)
secondMask, _ := NewSocketMask(tc.secondMaskBit) secondMask, _ := NewBitMask(tc.secondMaskBit)
result := Or(firstMask, secondMask) result := Or(firstMask, secondMask)
if result.String() != string(tc.orMask) { if result.String() != string(tc.orMask) {
@ -157,14 +157,14 @@ func TestClear(t *testing.T) {
clearedMask string clearedMask string
}{ }{
{ {
name: "Clear socket masks", name: "Clear bit masks",
firstBit: 0, firstBit: 0,
secondBit: 1, secondBit: 1,
clearedMask: "0000000000000000000000000000000000000000000000000000000000000000", clearedMask: "0000000000000000000000000000000000000000000000000000000000000000",
}, },
} }
for _, tc := range tcases { for _, tc := range tcases {
mask, _ := NewSocketMask(tc.firstBit, tc.secondBit) mask, _ := NewBitMask(tc.firstBit, tc.secondBit)
mask.Clear() mask.Clear()
if mask.String() != string(tc.clearedMask) { if mask.String() != string(tc.clearedMask) {
t.Errorf("Expected mask to be %v, got %v", tc.clearedMask, mask) t.Errorf("Expected mask to be %v, got %v", tc.clearedMask, mask)
@ -178,12 +178,12 @@ func TestFill(t *testing.T) {
filledMask string filledMask string
}{ }{
{ {
name: "Fill socket masks", name: "Fill bit masks",
filledMask: "1111111111111111111111111111111111111111111111111111111111111111", filledMask: "1111111111111111111111111111111111111111111111111111111111111111",
}, },
} }
for _, tc := range tcases { for _, tc := range tcases {
mask, _ := NewSocketMask() mask, _ := NewBitMask()
mask.Fill() mask.Fill()
if mask.String() != string(tc.filledMask) { if mask.String() != string(tc.filledMask) {
t.Errorf("Expected mask to be %v, got %v", tc.filledMask, mask) 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 { for _, tc := range tcases {
mask, _ := NewSocketMask(tc.maskBit) mask, _ := NewBitMask(tc.maskBit)
empty := mask.IsEmpty() empty := mask.IsEmpty()
if empty { if empty {
t.Errorf("Expected value to be %v, got %v", tc.expectedEmpty, 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 { for _, tc := range tcases {
mask, _ := NewSocketMask(tc.maskBit) mask, _ := NewBitMask(tc.maskBit)
set := mask.IsSet(tc.maskBit) set := mask.IsSet(tc.maskBit)
if !set { if !set {
t.Errorf("Expected value to be %v, got %v", tc.expectedSet, set) t.Errorf("Expected value to be %v, got %v", tc.expectedSet, set)
@ -241,15 +241,15 @@ func TestIsEqual(t *testing.T) {
isEqual bool isEqual bool
}{ }{
{ {
name: "Check if two socket masks are equal", name: "Check if two bit masks are equal",
firstMaskBit: 0, firstMaskBit: 0,
secondMaskBit: 0, secondMaskBit: 0,
isEqual: true, isEqual: true,
}, },
} }
for _, tc := range tcases { for _, tc := range tcases {
firstMask, _ := NewSocketMask(tc.firstMaskBit) firstMask, _ := NewBitMask(tc.firstMaskBit)
secondMask, _ := NewSocketMask(tc.secondMaskBit) secondMask, _ := NewBitMask(tc.secondMaskBit)
isEqual := firstMask.IsEqual(secondMask) isEqual := firstMask.IsEqual(secondMask)
if !isEqual { if !isEqual {
t.Errorf("Expected mask to be %v, got %v", tc.isEqual, 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 { for _, tc := range tcases {
mask, _ := NewSocketMask(tc.maskBit) mask, _ := NewBitMask(tc.maskBit)
count := mask.Count() count := mask.Count()
if count != tc.expectedCount { if count != tc.expectedCount {
t.Errorf("Expected value to be %v, got %v", tc.expectedCount, count) 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 { tcases := []struct {
name string name string
firstSocket int firstbit int
secondSocket int secondbit int
expectedSockets []int expectedbits []int
}{ }{
{ {
name: "Get number of each socket which has been set", name: "Get number of each bit which has been set",
firstSocket: 0, firstbit: 0,
secondSocket: 1, secondbit: 1,
expectedSockets: []int{0, 1}, expectedbits: []int{0, 1},
}, },
} }
for _, tc := range tcases { for _, tc := range tcases {
mask, _ := NewSocketMask(tc.firstSocket, tc.secondSocket) mask, _ := NewBitMask(tc.firstbit, tc.secondbit)
sockets := mask.GetSockets() bits := mask.GetBits()
if !reflect.DeepEqual(sockets, tc.expectedSockets) { if !reflect.DeepEqual(bits, tc.expectedbits) {
t.Errorf("Expected value to be %v, got %v", tc.expectedSockets, sockets) 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 { for _, tc := range tcases {
firstMask, _ := NewSocketMask(tc.firstMask...) firstMask, _ := NewBitMask(tc.firstMask...)
secondMask, _ := NewSocketMask(tc.secondMask...) secondMask, _ := NewBitMask(tc.secondMask...)
expectedFirstNarrower := firstMask.IsNarrowerThan(secondMask) expectedFirstNarrower := firstMask.IsNarrowerThan(secondMask)
if expectedFirstNarrower != tc.expectedFirstNarrower { if expectedFirstNarrower != tc.expectedFirstNarrower {
t.Errorf("Expected value to be %v, got %v", tc.expectedFirstNarrower, 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 { tcases := []struct {
name string name string
numSockets int numbits int
}{ }{
{ {
name: "1 Socket", name: "1 bit",
numSockets: 1, numbits: 1,
}, },
{ {
name: "2 Sockets", name: "2 bits",
numSockets: 2, numbits: 2,
}, },
{ {
name: "4 Sockets", name: "4 bits",
numSockets: 4, numbits: 4,
}, },
{ {
name: "8 Sockets", name: "8 bits",
numSockets: 8, numbits: 8,
}, },
{ {
name: "16 Sockets", name: "16 bits",
numSockets: 16, numbits: 16,
}, },
} }
for _, tc := range tcases { for _, tc := range tcases {
// Generate a list of sockets from tc.numSockets. // Generate a list of bits from tc.numbits.
var sockets []int var bits []int
for i := 0; i < tc.numSockets; i++ { for i := 0; i < tc.numbits; i++ {
sockets = append(sockets, i) bits = append(bits, i)
} }
// Calculate the expected number of masks. Since we always have masks // 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. // 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. // Iterate all masks and count them.
numMasks := 0 numMasks := 0
IterateSocketMasks(sockets, func(SocketMask) { IterateBitMasks(bits, func(BitMask) {
numMasks++ numMasks++
}) })

4
pkg/kubelet/cm/topologymanager/policy_single_numa_node_test.go
View File

@ -33,12 +33,12 @@ func TestPolicySingleNumaNodeCanAdmitPodResult(t *testing.T) {
}, },
{ {
name: "NUMANodeAffinity has multiple NUMA Nodes masked in topology hints", name: "NUMANodeAffinity has multiple NUMA Nodes masked in topology hints",
hint: TopologyHint{NewTestSocketMask(0, 1), true}, hint: TopologyHint{NewTestBitMask(0, 1), true},
expected: false, expected: false,
}, },
{ {
name: "NUMANodeAffinity has one NUMA Node masked in topology hints", name: "NUMANodeAffinity has one NUMA Node masked in topology hints",
hint: TopologyHint{NewTestSocketMask(0), true}, hint: TopologyHint{NewTestBitMask(0), true},
expected: true, expected: true,
}, },
} }

194
pkg/kubelet/cm/topologymanager/socketmask/socketmask.go
View File

@ -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)
}
}

10
pkg/kubelet/cm/topologymanager/topology_manager.go
View File

@ -22,7 +22,7 @@ import (
"k8s.io/api/core/v1" "k8s.io/api/core/v1"
"k8s.io/klog" "k8s.io/klog"
cputopology "k8s.io/kubernetes/pkg/kubelet/cm/cpumanager/topology" 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" "k8s.io/kubernetes/pkg/kubelet/lifecycle"
) )
@ -79,7 +79,7 @@ type Store interface {
//TopologyHint is a struct containing the NUMANodeAffinity for a Container //TopologyHint is a struct containing the NUMANodeAffinity for a Container
type TopologyHint struct { type TopologyHint struct {
NUMANodeAffinity socketmask.SocketMask NUMANodeAffinity bitmask.BitMask
// Preferred is set to true when the NUMANodeAffinity encodes a preferred // Preferred is set to true when the NUMANodeAffinity encodes a preferred
// allocation for the Container. It is set to false otherwise. // allocation for the Container. It is set to false otherwise.
Preferred bool Preferred bool
@ -179,7 +179,7 @@ func (m *manager) iterateAllProviderTopologyHints(allProviderHints [][]TopologyH
func (m *manager) calculateAffinity(pod v1.Pod, container v1.Container) TopologyHint { func (m *manager) calculateAffinity(pod v1.Pod, container v1.Container) TopologyHint {
// Set the default affinity as an any-numa affinity containing the list // Set the default affinity as an any-numa affinity containing the list
// of NUMA Nodes available on this machine. // 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 // Loop through all hint providers and save an accumulated list of the
// hints returned by each hint provider. If no hints are provided, assume // 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 // Get the NUMANodeAffinity from each hint in the permutation and see if any
// of them encode unpreferred allocations. // of them encode unpreferred allocations.
preferred := true preferred := true
var numaAffinities []socketmask.SocketMask var numaAffinities []bitmask.BitMask
for _, hint := range permutation { for _, hint := range permutation {
// Only consider hints that have an actual NUMANodeAffinity set. // Only consider hints that have an actual NUMANodeAffinity set.
if hint.NUMANodeAffinity != nil { 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. // Merge the affinities using a bitwise-and operation.
mergedAffinity, _ := socketmask.NewSocketMask(m.numaNodes...) mergedAffinity, _ := bitmask.NewBitMask(m.numaNodes...)
mergedAffinity.And(numaAffinities...) mergedAffinity.And(numaAffinities...)
// Build a mergedHintfrom the merged affinity mask, indicating if an // Build a mergedHintfrom the merged affinity mask, indicating if an

160
pkg/kubelet/cm/topologymanager/topology_manager_test.go
View File

@ -24,12 +24,12 @@ import (
"k8s.io/api/core/v1" "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/types" "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" "k8s.io/kubernetes/pkg/kubelet/lifecycle"
) )
func NewTestSocketMask(sockets ...int) socketmask.SocketMask { func NewTestBitMask(sockets ...int) bitmask.BitMask {
s, _ := socketmask.NewSocketMask(sockets...) s, _ := bitmask.NewBitMask(sockets...)
return s return s
} }
@ -117,7 +117,7 @@ func TestCalculateAffinity(t *testing.T) {
name: "TopologyHint not set", name: "TopologyHint not set",
hp: []HintProvider{}, hp: []HintProvider{},
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(numaNodes...), NUMANodeAffinity: NewTestBitMask(numaNodes...),
Preferred: true, Preferred: true,
}, },
}, },
@ -129,7 +129,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(numaNodes...), NUMANodeAffinity: NewTestBitMask(numaNodes...),
Preferred: true, Preferred: true,
}, },
}, },
@ -143,7 +143,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(numaNodes...), NUMANodeAffinity: NewTestBitMask(numaNodes...),
Preferred: true, Preferred: true,
}, },
}, },
@ -157,7 +157,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(numaNodes...), NUMANodeAffinity: NewTestBitMask(numaNodes...),
Preferred: false, Preferred: false,
}, },
}, },
@ -176,7 +176,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(numaNodes...), NUMANodeAffinity: NewTestBitMask(numaNodes...),
Preferred: true, Preferred: true,
}, },
}, },
@ -195,7 +195,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(numaNodes...), NUMANodeAffinity: NewTestBitMask(numaNodes...),
Preferred: true, Preferred: true,
}, },
}, },
@ -206,7 +206,7 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource1": { "resource1": {
{ {
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
}, },
@ -216,7 +216,7 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource2": { "resource2": {
{ {
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
}, },
@ -224,7 +224,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
}, },
@ -235,7 +235,7 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource1": { "resource1": {
{ {
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
}, },
@ -245,7 +245,7 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource2": { "resource2": {
{ {
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
}, },
@ -253,7 +253,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
}, },
@ -264,7 +264,7 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource1": { "resource1": {
{ {
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
}, },
@ -274,7 +274,7 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource2": { "resource2": {
{ {
NUMANodeAffinity: NewTestSocketMask(0, 1), NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: true, Preferred: true,
}, },
}, },
@ -282,7 +282,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
}, },
@ -293,7 +293,7 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource1": { "resource1": {
{ {
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
}, },
@ -303,7 +303,7 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource2": { "resource2": {
{ {
NUMANodeAffinity: NewTestSocketMask(0, 1), NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: true, Preferred: true,
}, },
}, },
@ -311,7 +311,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
}, },
@ -322,7 +322,7 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource1": { "resource1": {
{ {
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
}, },
@ -332,7 +332,7 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource2": { "resource2": {
{ {
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
}, },
@ -340,7 +340,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(numaNodes...), NUMANodeAffinity: NewTestBitMask(numaNodes...),
Preferred: false, Preferred: false,
}, },
}, },
@ -351,7 +351,7 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource1": { "resource1": {
{ {
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
}, },
@ -361,7 +361,7 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource2": { "resource2": {
{ {
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: false, Preferred: false,
}, },
}, },
@ -369,7 +369,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: false, Preferred: false,
}, },
}, },
@ -380,7 +380,7 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource1": { "resource1": {
{ {
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
}, },
@ -390,7 +390,7 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource2": { "resource2": {
{ {
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: false, Preferred: false,
}, },
}, },
@ -398,7 +398,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: false, Preferred: false,
}, },
}, },
@ -410,7 +410,7 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource": { "resource": {
{ {
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
}, },
@ -418,7 +418,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
}, },
@ -430,7 +430,7 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource": { "resource": {
{ {
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
}, },
@ -438,7 +438,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
}, },
@ -449,11 +449,11 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource1": { "resource1": {
{ {
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
{ {
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
}, },
@ -463,7 +463,7 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource2": { "resource2": {
{ {
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
}, },
@ -471,7 +471,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
}, },
@ -482,11 +482,11 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource1": { "resource1": {
{ {
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
{ {
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
}, },
@ -496,7 +496,7 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource2": { "resource2": {
{ {
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
}, },
@ -504,7 +504,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
}, },
@ -515,11 +515,11 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource1": { "resource1": {
{ {
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
{ {
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
}, },
@ -529,7 +529,7 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource2": { "resource2": {
{ {
NUMANodeAffinity: NewTestSocketMask(0, 1), NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false, Preferred: false,
}, },
}, },
@ -537,7 +537,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: false, Preferred: false,
}, },
}, },
@ -548,11 +548,11 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource1": { "resource1": {
{ {
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
{ {
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
}, },
@ -562,11 +562,11 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource2": { "resource2": {
{ {
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
{ {
NUMANodeAffinity: NewTestSocketMask(0, 1), NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false, Preferred: false,
}, },
}, },
@ -574,7 +574,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
}, },
@ -585,11 +585,11 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource1": { "resource1": {
{ {
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
{ {
NUMANodeAffinity: NewTestSocketMask(0, 1), NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false, Preferred: false,
}, },
}, },
@ -599,15 +599,15 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource2": { "resource2": {
{ {
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
{ {
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
{ {
NUMANodeAffinity: NewTestSocketMask(0, 1), NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false, Preferred: false,
}, },
}, },
@ -615,7 +615,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
}, },
@ -626,25 +626,25 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource1": { "resource1": {
{ {
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
{ {
NUMANodeAffinity: NewTestSocketMask(0, 1), NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false, Preferred: false,
}, },
}, },
"resource2": { "resource2": {
{ {
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
{ {
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
{ {
NUMANodeAffinity: NewTestSocketMask(0, 1), NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false, Preferred: false,
}, },
}, },
@ -652,7 +652,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
}, },
@ -664,21 +664,21 @@ func TestCalculateAffinity(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource1": { "resource1": {
{ {
NUMANodeAffinity: NewTestSocketMask(0, 1), NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: true, Preferred: true,
}, },
}, },
"resource2": { "resource2": {
{ {
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
{ {
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
{ {
NUMANodeAffinity: NewTestSocketMask(0, 1), NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false, Preferred: false,
}, },
}, },
@ -686,7 +686,7 @@ func TestCalculateAffinity(t *testing.T) {
}, },
}, },
expected: TopologyHint{ expected: TopologyHint{
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: false, Preferred: false,
}, },
}, },
@ -835,11 +835,11 @@ func TestAdmit(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource": { "resource": {
{ {
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
{ {
NUMANodeAffinity: NewTestSocketMask(0, 1), NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false, Preferred: false,
}, },
}, },
@ -857,15 +857,15 @@ func TestAdmit(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource": { "resource": {
{ {
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
{ {
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
{ {
NUMANodeAffinity: NewTestSocketMask(0, 1), NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false, Preferred: false,
}, },
}, },
@ -883,7 +883,7 @@ func TestAdmit(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource": { "resource": {
{ {
NUMANodeAffinity: NewTestSocketMask(0, 1), NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false, Preferred: false,
}, },
}, },
@ -901,11 +901,11 @@ func TestAdmit(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource": { "resource": {
{ {
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
{ {
NUMANodeAffinity: NewTestSocketMask(0, 1), NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false, Preferred: false,
}, },
}, },
@ -923,15 +923,15 @@ func TestAdmit(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource": { "resource": {
{ {
NUMANodeAffinity: NewTestSocketMask(0), NUMANodeAffinity: NewTestBitMask(0),
Preferred: true, Preferred: true,
}, },
{ {
NUMANodeAffinity: NewTestSocketMask(1), NUMANodeAffinity: NewTestBitMask(1),
Preferred: true, Preferred: true,
}, },
{ {
NUMANodeAffinity: NewTestSocketMask(0, 1), NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false, Preferred: false,
}, },
}, },
@ -949,7 +949,7 @@ func TestAdmit(t *testing.T) {
map[string][]TopologyHint{ map[string][]TopologyHint{
"resource": { "resource": {
{ {
NUMANodeAffinity: NewTestSocketMask(0, 1), NUMANodeAffinity: NewTestBitMask(0, 1),
Preferred: false, Preferred: false,
}, },
}, },