github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-24 20:24:09 +00:00
Code Issues Projects Releases Wiki Activity

memory manager: rename state structs and fields

Browse Source 
The commit rename state structs and some fields under these structs.

- NodeMap -> NUMANodeMap
- NodeState -> NUMANodeState
- NUMANodeState.Nodes -> NUMANodesState.Cells

Signed-off-by: Artyom Lukianov <alukiano@redhat.com>
This commit is contained in:
Artyom Lukianov 2020-11-04 14:28:04 +02:00
parent aa63e5aed2
commit a015e4163f
8 changed files with 331 additions and 331 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

258
pkg/kubelet/cm/memorymanager/memory_manager_test.go
View File

@ -48,8 +48,8 @@ type testMemoryManager struct {
machineInfo cadvisorapi.MachineInfo machineInfo cadvisorapi.MachineInfo
assignments state.ContainerMemoryAssignments assignments state.ContainerMemoryAssignments
expectedAssignments state.ContainerMemoryAssignments expectedAssignments state.ContainerMemoryAssignments
machineState state.NodeMap machineState state.NUMANodeMap
expectedMachineState state.NodeMap expectedMachineState state.NUMANodeMap
expectedError error expectedError error
expectedAllocateError error expectedAllocateError error
expectedAddContainerError error expectedAddContainerError error
@ -461,9 +461,9 @@ func TestRemoveStaleState(t *testing.T) {
}, },
}, },
}, },
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 4, NumberOfAssignments: 4,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -482,8 +482,8 @@ func TestRemoveStaleState(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -503,9 +503,9 @@ func TestRemoveStaleState(t *testing.T) {
}, },
}, },
}, },
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 4, NumberOfAssignments: 4,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -524,8 +524,8 @@ func TestRemoveStaleState(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -587,9 +587,9 @@ func TestRemoveStaleState(t *testing.T) {
}, },
}, },
expectedAssignments: state.ContainerMemoryAssignments{}, expectedAssignments: state.ContainerMemoryAssignments{},
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 4, NumberOfAssignments: 4,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -608,8 +608,8 @@ func TestRemoveStaleState(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -629,9 +629,9 @@ func TestRemoveStaleState(t *testing.T) {
}, },
}, },
}, },
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -650,8 +650,8 @@ func TestRemoveStaleState(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -713,9 +713,9 @@ func TestRemoveStaleState(t *testing.T) {
}, },
}, },
expectedAssignments: state.ContainerMemoryAssignments{}, expectedAssignments: state.ContainerMemoryAssignments{},
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0, 1}, Cells: []int{0, 1},
NumberOfAssignments: 4, NumberOfAssignments: 4,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -734,8 +734,8 @@ func TestRemoveStaleState(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{0, 1}, Cells: []int{0, 1},
NumberOfAssignments: 4, NumberOfAssignments: 4,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -755,9 +755,9 @@ func TestRemoveStaleState(t *testing.T) {
}, },
}, },
}, },
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -776,8 +776,8 @@ func TestRemoveStaleState(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -846,9 +846,9 @@ func TestAddContainer(t *testing.T) {
policyName: policyTypeStatic, policyName: policyTypeStatic,
machineInfo: machineInfo, machineInfo: machineInfo,
reserved: reserved, reserved: reserved,
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -867,8 +867,8 @@ func TestAddContainer(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -888,9 +888,9 @@ func TestAddContainer(t *testing.T) {
}, },
}, },
}, },
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 2, NumberOfAssignments: 2,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -909,8 +909,8 @@ func TestAddContainer(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -943,8 +943,8 @@ func TestAddContainer(t *testing.T) {
policyName: policyTypeNone, policyName: policyTypeNone,
machineInfo: machineInfo, machineInfo: machineInfo,
reserved: reserved, reserved: reserved,
machineState: state.NodeMap{}, machineState: state.NUMANodeMap{},
expectedMachineState: state.NodeMap{}, expectedMachineState: state.NUMANodeMap{},
expectedAllocateError: nil, expectedAllocateError: nil,
expectedAddContainerError: nil, expectedAddContainerError: nil,
podAllocate: pod, podAllocate: pod,
@ -957,9 +957,9 @@ func TestAddContainer(t *testing.T) {
policyName: policyTypeMock, policyName: policyTypeMock,
machineInfo: machineInfo, machineInfo: machineInfo,
reserved: reserved, reserved: reserved,
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -978,8 +978,8 @@ func TestAddContainer(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -999,9 +999,9 @@ func TestAddContainer(t *testing.T) {
}, },
}, },
}, },
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1020,8 +1020,8 @@ func TestAddContainer(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1053,9 +1053,9 @@ func TestAddContainer(t *testing.T) {
policyName: policyTypeStatic, policyName: policyTypeStatic,
machineInfo: machineInfo, machineInfo: machineInfo,
reserved: reserved, reserved: reserved,
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1074,8 +1074,8 @@ func TestAddContainer(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1095,9 +1095,9 @@ func TestAddContainer(t *testing.T) {
}, },
}, },
}, },
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1116,8 +1116,8 @@ func TestAddContainer(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1148,9 +1148,9 @@ func TestAddContainer(t *testing.T) {
policyName: policyTypeStatic, policyName: policyTypeStatic,
machineInfo: machineInfo, machineInfo: machineInfo,
reserved: reserved, reserved: reserved,
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1169,8 +1169,8 @@ func TestAddContainer(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1190,9 +1190,9 @@ func TestAddContainer(t *testing.T) {
}, },
}, },
}, },
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0, 1}, Cells: []int{0, 1},
NumberOfAssignments: 2, NumberOfAssignments: 2,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1211,8 +1211,8 @@ func TestAddContainer(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{0, 1}, Cells: []int{0, 1},
NumberOfAssignments: 2, NumberOfAssignments: 2,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1255,9 +1255,9 @@ func TestAddContainer(t *testing.T) {
machineInfo: machineInfo, machineInfo: machineInfo,
firstPod: pod, firstPod: pod,
reserved: reserved, reserved: reserved,
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 2, NumberOfAssignments: 2,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1276,8 +1276,8 @@ func TestAddContainer(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1313,9 +1313,9 @@ func TestAddContainer(t *testing.T) {
}, },
}, },
}, },
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 2, NumberOfAssignments: 2,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1334,8 +1334,8 @@ func TestAddContainer(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1488,9 +1488,9 @@ func TestRemoveContainer(t *testing.T) {
}, },
}, },
}, },
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 4, NumberOfAssignments: 4,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1509,8 +1509,8 @@ func TestRemoveContainer(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1530,9 +1530,9 @@ func TestRemoveContainer(t *testing.T) {
}, },
}, },
}, },
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 2, NumberOfAssignments: 2,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1551,8 +1551,8 @@ func TestRemoveContainer(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1624,9 +1624,9 @@ func TestRemoveContainer(t *testing.T) {
}, },
}, },
}, },
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0, 1}, Cells: []int{0, 1},
NumberOfAssignments: 4, NumberOfAssignments: 4,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1645,8 +1645,8 @@ func TestRemoveContainer(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{0, 1}, Cells: []int{0, 1},
NumberOfAssignments: 4, NumberOfAssignments: 4,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1666,9 +1666,9 @@ func TestRemoveContainer(t *testing.T) {
}, },
}, },
}, },
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0, 1}, Cells: []int{0, 1},
NumberOfAssignments: 2, NumberOfAssignments: 2,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1687,8 +1687,8 @@ func TestRemoveContainer(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{0, 1}, Cells: []int{0, 1},
NumberOfAssignments: 2, NumberOfAssignments: 2,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1772,9 +1772,9 @@ func TestRemoveContainer(t *testing.T) {
}, },
}, },
}, },
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 4, NumberOfAssignments: 4,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1793,8 +1793,8 @@ func TestRemoveContainer(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1814,9 +1814,9 @@ func TestRemoveContainer(t *testing.T) {
}, },
}, },
}, },
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 4, NumberOfAssignments: 4,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1835,8 +1835,8 @@ func TestRemoveContainer(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1920,9 +1920,9 @@ func TestRemoveContainer(t *testing.T) {
}, },
}, },
}, },
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 4, NumberOfAssignments: 4,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1941,8 +1941,8 @@ func TestRemoveContainer(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1962,9 +1962,9 @@ func TestRemoveContainer(t *testing.T) {
}, },
}, },
}, },
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 4, NumberOfAssignments: 4,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -1983,8 +1983,8 @@ func TestRemoveContainer(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -2193,9 +2193,9 @@ func TestGetTopologyHints(t *testing.T) {
}, },
}, },
}, },
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 4, NumberOfAssignments: 4,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
@ -2214,8 +2214,8 @@ func TestGetTopologyHints(t *testing.T) {
}, },
}, },
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {

34
pkg/kubelet/cm/memorymanager/policy_static.go
View File

@ -37,7 +37,7 @@ const policyTypeStatic policyType = "static"
type systemReservedMemory map[int]map[v1.ResourceName]uint64 type systemReservedMemory map[int]map[v1.ResourceName]uint64
// SingleNUMAPolicy is implementation of the policy interface for the single NUMA policy // staticPolicy is implementation of the policy interface for the static policy
type staticPolicy struct { type staticPolicy struct {
// machineInfo contains machine memory related information // machineInfo contains machine memory related information
machineInfo *cadvisorapi.MachineInfo machineInfo *cadvisorapi.MachineInfo
@ -49,7 +49,7 @@ type staticPolicy struct {
var _ Policy = &staticPolicy{} var _ Policy = &staticPolicy{}
// NewPolicyStatic returns new single NUMA policy instance // NewPolicyStatic returns new static policy instance
func NewPolicyStatic(machineInfo *cadvisorapi.MachineInfo, reserved systemReservedMemory, affinity topologymanager.Store) (Policy, error) { func NewPolicyStatic(machineInfo *cadvisorapi.MachineInfo, reserved systemReservedMemory, affinity topologymanager.Store) (Policy, error) {
var totalSystemReserved uint64 var totalSystemReserved uint64
for _, node := range reserved { for _, node := range reserved {
@ -149,7 +149,7 @@ func (p *staticPolicy) Allocate(s state.State, pod *v1.Pod, container *v1.Contai
// Update nodes memory state // Update nodes memory state
for _, nodeID := range maskBits { for _, nodeID := range maskBits {
machineState[nodeID].NumberOfAssignments++ machineState[nodeID].NumberOfAssignments++
machineState[nodeID].Nodes = maskBits machineState[nodeID].Cells = maskBits
// we need to continue to update all affinity mask nodes // we need to continue to update all affinity mask nodes
if requestedSize == 0 { if requestedSize == 0 {
@ -202,7 +202,7 @@ func (p *staticPolicy) RemoveContainer(s state.State, podUID string, containerNa
// once we do not have any memory allocations on this node, clear node groups // once we do not have any memory allocations on this node, clear node groups
if machineState[nodeID].NumberOfAssignments == 0 { if machineState[nodeID].NumberOfAssignments == 0 {
machineState[nodeID].Nodes = []int{nodeID} machineState[nodeID].Cells = []int{nodeID}
} }
// we still need to pass over all NUMA node under the affinity mask to update them // we still need to pass over all NUMA node under the affinity mask to update them
@ -390,7 +390,7 @@ func (p *staticPolicy) calculateHints(s state.State, requestedResources map[v1.R
} }
sort.Ints(numaNodes) sort.Ints(numaNodes)
// Initialize minAffinitySize to include all NUMA Nodes. // Initialize minAffinitySize to include all NUMA Cells.
minAffinitySize := len(numaNodes) minAffinitySize := len(numaNodes)
hints := map[string][]topologymanager.TopologyHint{} hints := map[string][]topologymanager.TopologyHint{}
@ -399,7 +399,7 @@ func (p *staticPolicy) calculateHints(s state.State, requestedResources map[v1.R
singleNUMAHint := len(maskBits) == 1 singleNUMAHint := len(maskBits) == 1
// the node already in group with another node, it can not be used for the single NUMA node allocation // the node already in group with another node, it can not be used for the single NUMA node allocation
if singleNUMAHint && len(machineState[maskBits[0]].Nodes) > 1 { if singleNUMAHint && len(machineState[maskBits[0]].Cells) > 1 {
return return
} }
@ -410,12 +410,12 @@ func (p *staticPolicy) calculateHints(s state.State, requestedResources map[v1.R
// the node already used for the memory allocation // the node already used for the memory allocation
if !singleNUMAHint && machineState[nodeID].NumberOfAssignments > 0 { if !singleNUMAHint && machineState[nodeID].NumberOfAssignments > 0 {
// the node used for the single NUMA memory allocation, it can not be used for the multi NUMA node allocation // the node used for the single NUMA memory allocation, it can not be used for the multi NUMA node allocation
if len(machineState[nodeID].Nodes) == 1 { if len(machineState[nodeID].Cells) == 1 {
return return
} }
// the node already used with different group of nodes, it can not be use with in the current hint // the node already used with different group of nodes, it can not be use with in the current hint
if !areGroupsEqual(machineState[nodeID].Nodes, maskBits) { if !areGroupsEqual(machineState[nodeID].Cells, maskBits) {
return return
} }
} }
@ -524,7 +524,7 @@ func (p *staticPolicy) validateState(s state.State) error {
} }
nodeState.NumberOfAssignments++ nodeState.NumberOfAssignments++
nodeState.Nodes = b.NUMAAffinity nodeState.Cells = b.NUMAAffinity
memoryState, ok := nodeState.MemoryMap[b.Type] memoryState, ok := nodeState.MemoryMap[b.Type]
if !ok { if !ok {
@ -568,7 +568,7 @@ func (p *staticPolicy) validateState(s state.State) error {
return nil return nil
} }
func areMachineStatesEqual(ms1, ms2 state.NodeMap) bool { func areMachineStatesEqual(ms1, ms2 state.NUMANodeMap) bool {
if len(ms1) != len(ms2) { if len(ms1) != len(ms2) {
klog.Errorf("[memorymanager] node states are different len(ms1) != len(ms2): %d != %d", len(ms1), len(ms2)) klog.Errorf("[memorymanager] node states are different len(ms1) != len(ms2): %d != %d", len(ms1), len(ms2))
return false return false
@ -586,8 +586,8 @@ func areMachineStatesEqual(ms1, ms2 state.NodeMap) bool {
return false return false
} }
if !areGroupsEqual(nodeState1.Nodes, nodeState2.Nodes) { if !areGroupsEqual(nodeState1.Cells, nodeState2.Cells) {
klog.Errorf("[memorymanager] node states groups are different: %v != %v", nodeState1.Nodes, nodeState2.Nodes) klog.Errorf("[memorymanager] node states groups are different: %v != %v", nodeState1.Cells, nodeState2.Cells)
return false return false
} }
@ -612,14 +612,14 @@ func areMachineStatesEqual(ms1, ms2 state.NodeMap) bool {
return true return true
} }
func (p *staticPolicy) getDefaultMachineState() state.NodeMap { func (p *staticPolicy) getDefaultMachineState() state.NUMANodeMap {
defaultMachineState := state.NodeMap{} defaultMachineState := state.NUMANodeMap{}
nodeHugepages := map[int]uint64{} nodeHugepages := map[int]uint64{}
for _, node := range p.machineInfo.Topology { for _, node := range p.machineInfo.Topology {
defaultMachineState[node.Id] = &state.NodeState{ defaultMachineState[node.Id] = &state.NUMANodeState{
NumberOfAssignments: 0, NumberOfAssignments: 0,
MemoryMap: map[v1.ResourceName]*state.MemoryTable{}, MemoryMap: map[v1.ResourceName]*state.MemoryTable{},
Nodes: []int{node.Id}, Cells: []int{node.Id},
} }
// fill memory table with huge pages values // fill memory table with huge pages values
@ -681,7 +681,7 @@ func (p *staticPolicy) getDefaultHint(s state.State, requestedResources map[v1.R
return findBestHint(hints[string(v1.ResourceMemory)]), nil return findBestHint(hints[string(v1.ResourceMemory)]), nil
} }
func isAffinitySatisfyRequest(machineState state.NodeMap, mask bitmask.BitMask, requestedResources map[v1.ResourceName]uint64) bool { func isAffinitySatisfyRequest(machineState state.NUMANodeMap, mask bitmask.BitMask, requestedResources map[v1.ResourceName]uint64) bool {
totalFreeSize := map[v1.ResourceName]uint64{} totalFreeSize := map[v1.ResourceName]uint64{}
for _, nodeID := range mask.GetBits() { for _, nodeID := range mask.GetBits() {
for resourceName := range requestedResources { for resourceName := range requestedResources {

278
pkg/kubelet/cm/memorymanager/policy_static_test.go
View File

@ -119,8 +119,8 @@ type testStaticPolicy struct {
description string description string
assignments state.ContainerMemoryAssignments assignments state.ContainerMemoryAssignments
expectedAssignments state.ContainerMemoryAssignments expectedAssignments state.ContainerMemoryAssignments
machineState state.NodeMap machineState state.NUMANodeMap
expectedMachineState state.NodeMap expectedMachineState state.NUMANodeMap
systemReserved systemReservedMemory systemReserved systemReservedMemory
expectedError error expectedError error
machineInfo *cadvisorapi.MachineInfo machineInfo *cadvisorapi.MachineInfo
@ -229,8 +229,8 @@ func TestStaticPolicyStart(t *testing.T) {
{ {
description: "should fill the state with default values, when the state is empty", description: "should fill the state with default values, when the state is empty",
expectedAssignments: state.ContainerMemoryAssignments{}, expectedAssignments: state.ContainerMemoryAssignments{},
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -248,7 +248,7 @@ func TestStaticPolicyStart(t *testing.T) {
}, },
}, },
NumberOfAssignments: 0, NumberOfAssignments: 0,
Nodes: []int{0}, Cells: []int{0},
}, },
}, },
systemReserved: systemReservedMemory{ systemReserved: systemReservedMemory{
@ -274,8 +274,8 @@ func TestStaticPolicyStart(t *testing.T) {
}, },
{ {
description: "should fail when machine state does not have all NUMA nodes", description: "should fail when machine state does not have all NUMA nodes",
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -292,7 +292,7 @@ func TestStaticPolicyStart(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
}, },
@ -331,8 +331,8 @@ func TestStaticPolicyStart(t *testing.T) {
}, },
{ {
description: "should fail when machine state does not have memory resource", description: "should fail when machine state does not have memory resource",
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
hugepages1Gi: { hugepages1Gi: {
Allocatable: gb, Allocatable: gb,
@ -342,7 +342,7 @@ func TestStaticPolicyStart(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
}, },
@ -370,8 +370,8 @@ func TestStaticPolicyStart(t *testing.T) {
}, },
{ {
description: "should fail when machine state has wrong size of total memory", description: "should fail when machine state has wrong size of total memory",
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -381,7 +381,7 @@ func TestStaticPolicyStart(t *testing.T) {
TotalMemSize: 1536 * mb, TotalMemSize: 1536 * mb,
}, },
}, },
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
}, },
@ -409,8 +409,8 @@ func TestStaticPolicyStart(t *testing.T) {
}, },
{ {
description: "should fail when machine state has wrong size of system reserved memory", description: "should fail when machine state has wrong size of system reserved memory",
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -420,7 +420,7 @@ func TestStaticPolicyStart(t *testing.T) {
TotalMemSize: 2 * gb, TotalMemSize: 2 * gb,
}, },
}, },
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
}, },
@ -459,8 +459,8 @@ func TestStaticPolicyStart(t *testing.T) {
}, },
}, },
}, },
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -470,7 +470,7 @@ func TestStaticPolicyStart(t *testing.T) {
TotalMemSize: 2 * gb, TotalMemSize: 2 * gb,
}, },
}, },
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 1, NumberOfAssignments: 1,
}, },
}, },
@ -498,8 +498,8 @@ func TestStaticPolicyStart(t *testing.T) {
}, },
{ {
description: "should fail when machine state has wrong size of hugepages", description: "should fail when machine state has wrong size of hugepages",
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -516,7 +516,7 @@ func TestStaticPolicyStart(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
}, },
@ -544,8 +544,8 @@ func TestStaticPolicyStart(t *testing.T) {
}, },
{ {
description: "should fail when machine state has wrong size of system reserved hugepages", description: "should fail when machine state has wrong size of system reserved hugepages",
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -562,7 +562,7 @@ func TestStaticPolicyStart(t *testing.T) {
TotalMemSize: 2 * gb, TotalMemSize: 2 * gb,
}, },
}, },
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
}, },
@ -610,8 +610,8 @@ func TestStaticPolicyStart(t *testing.T) {
}, },
}, },
}, },
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -628,7 +628,7 @@ func TestStaticPolicyStart(t *testing.T) {
TotalMemSize: 4 * gb, TotalMemSize: 4 * gb,
}, },
}, },
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 2, NumberOfAssignments: 2,
}, },
}, },
@ -667,8 +667,8 @@ func TestStaticPolicyStart(t *testing.T) {
}, },
}, },
}, },
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -685,7 +685,7 @@ func TestStaticPolicyStart(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
}, },
@ -729,8 +729,8 @@ func TestStaticPolicyStart(t *testing.T) {
}, },
}, },
}, },
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -747,7 +747,7 @@ func TestStaticPolicyStart(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 2, NumberOfAssignments: 2,
}, },
}, },
@ -791,8 +791,8 @@ func TestStaticPolicyStart(t *testing.T) {
}, },
}, },
}, },
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -809,7 +809,7 @@ func TestStaticPolicyStart(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 1, NumberOfAssignments: 1,
}, },
}, },
@ -897,8 +897,8 @@ func TestStaticPolicyStart(t *testing.T) {
}, },
}, },
}, },
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 640 * mb, Allocatable: 640 * mb,
@ -915,10 +915,10 @@ func TestStaticPolicyStart(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0, 1}, Cells: []int{0, 1},
NumberOfAssignments: 4, NumberOfAssignments: 4,
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 640 * mb, Allocatable: 640 * mb,
@ -935,12 +935,12 @@ func TestStaticPolicyStart(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0, 1}, Cells: []int{0, 1},
NumberOfAssignments: 4, NumberOfAssignments: 4,
}, },
}, },
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 640 * mb, Allocatable: 640 * mb,
@ -957,10 +957,10 @@ func TestStaticPolicyStart(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0, 1}, Cells: []int{0, 1},
NumberOfAssignments: 4, NumberOfAssignments: 4,
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 640 * mb, Allocatable: 640 * mb,
@ -977,7 +977,7 @@ func TestStaticPolicyStart(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0, 1}, Cells: []int{0, 1},
NumberOfAssignments: 4, NumberOfAssignments: 4,
}, },
}, },
@ -1053,8 +1053,8 @@ func TestStaticPolicyAllocate(t *testing.T) {
{ {
description: "should do nothing for non-guaranteed pods", description: "should do nothing for non-guaranteed pods",
expectedAssignments: state.ContainerMemoryAssignments{}, expectedAssignments: state.ContainerMemoryAssignments{},
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -1071,11 +1071,11 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{}, Cells: []int{},
}, },
}, },
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -1092,7 +1092,7 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{}, Cells: []int{},
}, },
}, },
systemReserved: systemReservedMemory{ systemReserved: systemReservedMemory{
@ -1128,8 +1128,8 @@ func TestStaticPolicyAllocate(t *testing.T) {
}, },
}, },
}, },
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -1146,11 +1146,11 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{}, Cells: []int{},
}, },
}, },
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -1167,7 +1167,7 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{}, Cells: []int{},
}, },
}, },
systemReserved: systemReservedMemory{ systemReserved: systemReservedMemory{
@ -1198,8 +1198,8 @@ func TestStaticPolicyAllocate(t *testing.T) {
}, },
}, },
}, },
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -1216,11 +1216,11 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0}, Cells: []int{0},
}, },
}, },
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -1237,7 +1237,7 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 2, NumberOfAssignments: 2,
}, },
}, },
@ -1267,8 +1267,8 @@ func TestStaticPolicyAllocate(t *testing.T) {
}, },
}, },
}, },
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -1285,7 +1285,7 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 2, NumberOfAssignments: 2,
}, },
}, },
@ -1311,8 +1311,8 @@ func TestStaticPolicyAllocate(t *testing.T) {
}, },
}, },
}, },
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: gb, Allocatable: gb,
@ -1329,10 +1329,10 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 1, NumberOfAssignments: 1,
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 512 * mb, Allocatable: 512 * mb,
@ -1349,10 +1349,10 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
2: &state.NodeState{ 2: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 512 * mb, Allocatable: 512 * mb,
@ -1369,7 +1369,7 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{2}, Cells: []int{2},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
}, },
@ -1390,8 +1390,8 @@ func TestStaticPolicyAllocate(t *testing.T) {
}, },
{ {
description: "should fail when NUMA affinity provided under the topology manager hint did not satisfy container requirements and extended hint generation failed", description: "should fail when NUMA affinity provided under the topology manager hint did not satisfy container requirements and extended hint generation failed",
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 512 * mb, Allocatable: 512 * mb,
@ -1408,10 +1408,10 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -1428,10 +1428,10 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{1, 2}, Cells: []int{1, 2},
NumberOfAssignments: 1, NumberOfAssignments: 1,
}, },
2: &state.NodeState{ 2: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -1448,7 +1448,7 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{1, 2}, Cells: []int{1, 2},
NumberOfAssignments: 1, NumberOfAssignments: 1,
}, },
}, },
@ -1480,8 +1480,8 @@ func TestStaticPolicyAllocate(t *testing.T) {
}, },
}, },
}, },
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: gb, Allocatable: gb,
@ -1498,10 +1498,10 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 1, NumberOfAssignments: 1,
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 512 * mb, Allocatable: 512 * mb,
@ -1518,10 +1518,10 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
2: &state.NodeState{ 2: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 512 * mb, Allocatable: 512 * mb,
@ -1538,7 +1538,7 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{2}, Cells: []int{2},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
}, },
@ -1576,8 +1576,8 @@ func TestStaticPolicyAllocate(t *testing.T) {
}, },
}, },
}, },
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 512 * mb, Allocatable: 512 * mb,
@ -1594,10 +1594,10 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 512 * mb, Allocatable: 512 * mb,
@ -1614,10 +1614,10 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{1}, Cells: []int{1},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
2: &state.NodeState{ 2: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 512 * mb, Allocatable: 512 * mb,
@ -1634,10 +1634,10 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{2}, Cells: []int{2},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
3: &state.NodeState{ 3: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 512 * mb, Allocatable: 512 * mb,
@ -1654,12 +1654,12 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{3}, Cells: []int{3},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
}, },
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 512 * mb, Allocatable: 512 * mb,
@ -1676,10 +1676,10 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0, 1}, Cells: []int{0, 1},
NumberOfAssignments: 2, NumberOfAssignments: 2,
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 512 * mb, Allocatable: 512 * mb,
@ -1696,10 +1696,10 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0, 1}, Cells: []int{0, 1},
NumberOfAssignments: 2, NumberOfAssignments: 2,
}, },
2: &state.NodeState{ 2: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 512 * mb, Allocatable: 512 * mb,
@ -1716,10 +1716,10 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{2}, Cells: []int{2},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
3: &state.NodeState{ 3: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 512 * mb, Allocatable: 512 * mb,
@ -1736,7 +1736,7 @@ func TestStaticPolicyAllocate(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{3}, Cells: []int{3},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
}, },
@ -1794,8 +1794,8 @@ func TestStaticPolicyRemoveContainer(t *testing.T) {
{ {
description: "should do nothing when the container does not exist under the state", description: "should do nothing when the container does not exist under the state",
expectedAssignments: state.ContainerMemoryAssignments{}, expectedAssignments: state.ContainerMemoryAssignments{},
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -1812,11 +1812,11 @@ func TestStaticPolicyRemoveContainer(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{}, Cells: []int{},
}, },
}, },
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -1833,7 +1833,7 @@ func TestStaticPolicyRemoveContainer(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{}, Cells: []int{},
}, },
}, },
systemReserved: systemReservedMemory{ systemReserved: systemReservedMemory{
@ -1861,8 +1861,8 @@ func TestStaticPolicyRemoveContainer(t *testing.T) {
}, },
}, },
expectedAssignments: state.ContainerMemoryAssignments{}, expectedAssignments: state.ContainerMemoryAssignments{},
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -1880,11 +1880,11 @@ func TestStaticPolicyRemoveContainer(t *testing.T) {
}, },
}, },
NumberOfAssignments: 2, NumberOfAssignments: 2,
Nodes: []int{0}, Cells: []int{0},
}, },
}, },
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -1901,7 +1901,7 @@ func TestStaticPolicyRemoveContainer(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0}, Cells: []int{0},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
}, },
@ -1930,8 +1930,8 @@ func TestStaticPolicyRemoveContainer(t *testing.T) {
}, },
}, },
expectedAssignments: state.ContainerMemoryAssignments{}, expectedAssignments: state.ContainerMemoryAssignments{},
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 512 * mb, Allocatable: 512 * mb,
@ -1949,9 +1949,9 @@ func TestStaticPolicyRemoveContainer(t *testing.T) {
}, },
}, },
NumberOfAssignments: 2, NumberOfAssignments: 2,
Nodes: []int{0, 1}, Cells: []int{0, 1},
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 512 * mb, Allocatable: 512 * mb,
@ -1969,11 +1969,11 @@ func TestStaticPolicyRemoveContainer(t *testing.T) {
}, },
}, },
NumberOfAssignments: 2, NumberOfAssignments: 2,
Nodes: []int{0, 1}, Cells: []int{0, 1},
}, },
}, },
expectedMachineState: state.NodeMap{ expectedMachineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 512 * mb, Allocatable: 512 * mb,
@ -1991,9 +1991,9 @@ func TestStaticPolicyRemoveContainer(t *testing.T) {
}, },
}, },
NumberOfAssignments: 0, NumberOfAssignments: 0,
Nodes: []int{0}, Cells: []int{0},
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 512 * mb, Allocatable: 512 * mb,
@ -2011,7 +2011,7 @@ func TestStaticPolicyRemoveContainer(t *testing.T) {
}, },
}, },
NumberOfAssignments: 0, NumberOfAssignments: 0,
Nodes: []int{1}, Cells: []int{1},
}, },
}, },
systemReserved: systemReservedMemory{ systemReserved: systemReservedMemory{
@ -2123,8 +2123,8 @@ func TestStaticPolicyGetTopologyHints(t *testing.T) {
}, },
}, },
}, },
machineState: state.NodeMap{ machineState: state.NUMANodeMap{
0: &state.NodeState{ 0: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -2141,10 +2141,10 @@ func TestStaticPolicyGetTopologyHints(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0, 1}, Cells: []int{0, 1},
NumberOfAssignments: 2, NumberOfAssignments: 2,
}, },
1: &state.NodeState{ 1: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -2161,10 +2161,10 @@ func TestStaticPolicyGetTopologyHints(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{0, 1}, Cells: []int{0, 1},
NumberOfAssignments: 2, NumberOfAssignments: 2,
}, },
2: &state.NodeState{ 2: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -2181,10 +2181,10 @@ func TestStaticPolicyGetTopologyHints(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{2}, Cells: []int{2},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
3: &state.NodeState{ 3: &state.NUMANodeState{
MemoryMap: map[v1.ResourceName]*state.MemoryTable{ MemoryMap: map[v1.ResourceName]*state.MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536 * mb, Allocatable: 1536 * mb,
@ -2201,7 +2201,7 @@ func TestStaticPolicyGetTopologyHints(t *testing.T) {
TotalMemSize: gb, TotalMemSize: gb,
}, },
}, },
Nodes: []int{3}, Cells: []int{3},
NumberOfAssignments: 0, NumberOfAssignments: 0,
}, },
}, },

4
pkg/kubelet/cm/memorymanager/state/checkpoint.go
View File

@ -28,7 +28,7 @@ var _ checkpointmanager.Checkpoint = &MemoryManagerCheckpoint{}
// MemoryManagerCheckpoint struct is used to store memory/pod assignments in a checkpoint // MemoryManagerCheckpoint struct is used to store memory/pod assignments in a checkpoint
type MemoryManagerCheckpoint struct { type MemoryManagerCheckpoint struct {
PolicyName string `json:"policyName"` PolicyName string `json:"policyName"`
MachineState NodeMap `json:"machineState"` MachineState NUMANodeMap `json:"machineState"`
Entries ContainerMemoryAssignments `json:"entries,omitempty"` Entries ContainerMemoryAssignments `json:"entries,omitempty"`
Checksum checksum.Checksum `json:"checksum"` Checksum checksum.Checksum `json:"checksum"`
} }
@ -38,7 +38,7 @@ func NewMemoryManagerCheckpoint() *MemoryManagerCheckpoint {
//lint:ignore unexported-type-in-api user-facing error message //lint:ignore unexported-type-in-api user-facing error message
return &MemoryManagerCheckpoint{ return &MemoryManagerCheckpoint{
Entries: ContainerMemoryAssignments{}, Entries: ContainerMemoryAssignments{},
MachineState: NodeMap{}, MachineState: NUMANodeMap{},
} }
} }

28
pkg/kubelet/cm/memorymanager/state/state.go
View File

@ -29,35 +29,35 @@ type MemoryTable struct {
Free uint64 `json:"free"` Free uint64 `json:"free"`
} }
// NodeState contains NUMA node related information // NUMANodeState contains NUMA node related information
type NodeState struct { type NUMANodeState struct {
// NumberOfAssignments contains a number memory assignments from this node // NumberOfAssignments contains a number memory assignments from this node
// When the container requires memory and hugepages it will increase number of assignments by two // When the container requires memory and hugepages it will increase number of assignments by two
NumberOfAssignments int `json:"numberOfAssignments"` NumberOfAssignments int `json:"numberOfAssignments"`
// MemoryTable contains NUMA node memory related information // MemoryTable contains NUMA node memory related information
MemoryMap map[v1.ResourceName]*MemoryTable `json:"memoryMap"` MemoryMap map[v1.ResourceName]*MemoryTable `json:"memoryMap"`
// Nodes contains the current NUMA node and all other nodes that are in a group with current NUMA node // Cells contains the current NUMA node and all other nodes that are in a group with current NUMA node
// This parameter indicates if the current node is used for the multiple NUMA node memory allocation // This parameter indicates if the current node is used for the multiple NUMA node memory allocation
// For example if some container has pinning 0,1,2, NUMA nodes 0,1,2 under the state will have // For example if some container has pinning 0,1,2, NUMA nodes 0,1,2 under the state will have
// this parameter equals to [0, 1, 2] // this parameter equals to [0, 1, 2]
Nodes []int `json:"nodes"` Cells []int `json:"cells"`
} }
// NodeMap contains memory information for each NUMA node. // NUMANodeMap contains memory information for each NUMA node.
type NodeMap map[int]*NodeState type NUMANodeMap map[int]*NUMANodeState
// Clone returns a copy of NodeMap // Clone returns a copy of NUMANodeMap
func (nm NodeMap) Clone() NodeMap { func (nm NUMANodeMap) Clone() NUMANodeMap {
clone := make(NodeMap) clone := make(NUMANodeMap)
for node, s := range nm { for node, s := range nm {
if s == nil { if s == nil {
clone[node] = nil clone[node] = nil
continue continue
} }
clone[node] = &NodeState{} clone[node] = &NUMANodeState{}
clone[node].NumberOfAssignments = s.NumberOfAssignments clone[node].NumberOfAssignments = s.NumberOfAssignments
clone[node].Nodes = append([]int{}, s.Nodes...) clone[node].Cells = append([]int{}, s.Cells...)
if s.MemoryMap == nil { if s.MemoryMap == nil {
continue continue
@ -103,7 +103,7 @@ func (as ContainerMemoryAssignments) Clone() ContainerMemoryAssignments {
// Reader interface used to read current memory/pod assignment state // Reader interface used to read current memory/pod assignment state
type Reader interface { type Reader interface {
// GetMachineState returns Memory Map stored in the State // GetMachineState returns Memory Map stored in the State
GetMachineState() NodeMap GetMachineState() NUMANodeMap
// GetMemoryBlocks returns memory assignments of a container // GetMemoryBlocks returns memory assignments of a container
GetMemoryBlocks(podUID string, containerName string) []Block GetMemoryBlocks(podUID string, containerName string) []Block
// GetMemoryAssignments returns ContainerMemoryAssignments // GetMemoryAssignments returns ContainerMemoryAssignments
@ -111,8 +111,8 @@ type Reader interface {
} }
type writer interface { type writer interface {
// SetMachineState stores NodeMap in State // SetMachineState stores NUMANodeMap in State
SetMachineState(memoryMap NodeMap) SetMachineState(memoryMap NUMANodeMap)
// SetMemoryBlocks stores memory assignments of a container // SetMemoryBlocks stores memory assignments of a container
SetMemoryBlocks(podUID string, containerName string, blocks []Block) SetMemoryBlocks(podUID string, containerName string, blocks []Block)
// SetMemoryAssignments sets ContainerMemoryAssignments by using the passed parameter // SetMemoryAssignments sets ContainerMemoryAssignments by using the passed parameter

6
pkg/kubelet/cm/memorymanager/state/state_checkpoint.go
View File

@ -103,7 +103,7 @@ func (sc *stateCheckpoint) storeState() error {
} }
// GetMemoryState returns Memory Map stored in the State // GetMemoryState returns Memory Map stored in the State
func (sc *stateCheckpoint) GetMachineState() NodeMap { func (sc *stateCheckpoint) GetMachineState() NUMANodeMap {
sc.RLock() sc.RLock()
defer sc.RUnlock() defer sc.RUnlock()
@ -126,8 +126,8 @@ func (sc *stateCheckpoint) GetMemoryAssignments() ContainerMemoryAssignments {
return sc.cache.GetMemoryAssignments() return sc.cache.GetMemoryAssignments()
} }
// SetMachineState stores NodeMap in State // SetMachineState stores NUMANodeMap in State
func (sc *stateCheckpoint) SetMachineState(memoryMap NodeMap) { func (sc *stateCheckpoint) SetMachineState(memoryMap NUMANodeMap) {
sc.Lock() sc.Lock()
defer sc.Unlock() defer sc.Unlock()

42
pkg/kubelet/cm/memorymanager/state/state_checkpoint_test.go
View File

@ -62,9 +62,9 @@ func TestCheckpointStateRestore(t *testing.T) {
"Restore valid checkpoint", "Restore valid checkpoint",
`{ `{
"policyName":"static", "policyName":"static",
"machineState":{"0":{"numberOfAssignments":0,"memoryMap":{"memory":{"total":2048,"systemReserved":512,"allocatable":1536,"reserved":512,"free":1024}},"nodes":[]}}, "machineState":{"0":{"numberOfAssignments":0,"memoryMap":{"memory":{"total":2048,"systemReserved":512,"allocatable":1536,"reserved":512,"free":1024}},"cells":[]}},
"entries":{"pod":{"container1":[{"numaAffinity":[0],"type":"memory","size":512}]}}, "entries":{"pod":{"container1":[{"numaAffinity":[0],"type":"memory","size":512}]}},
"checksum": 163710462 "checksum": 4215593881
}`, }`,
containermap.ContainerMap{}, containermap.ContainerMap{},
"", "",
@ -80,8 +80,8 @@ func TestCheckpointStateRestore(t *testing.T) {
}, },
}, },
}, },
machineState: NodeMap{ machineState: NUMANodeMap{
0: &NodeState{ 0: &NUMANodeState{
MemoryMap: map[v1.ResourceName]*MemoryTable{ MemoryMap: map[v1.ResourceName]*MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536, Allocatable: 1536,
@ -99,7 +99,7 @@ func TestCheckpointStateRestore(t *testing.T) {
"Restore checkpoint with invalid checksum", "Restore checkpoint with invalid checksum",
`{ `{
"policyName":"static", "policyName":"static",
"machineState":{"0":{"numberOfAssignments":0,"memoryMap":{"memory":{"total":2048,"systemReserved":512,"allocatable":1536,"reserved":512,"free":1024}},"nodes":[]}}, "machineState":{"0":{"numberOfAssignments":0,"memoryMap":{"memory":{"total":2048,"systemReserved":512,"allocatable":1536,"reserved":512,"free":1024}},"cells":[]}},
"entries":{"pod":{"container1":[{"affinity":[0],"type":"memory","size":512}]}}, "entries":{"pod":{"container1":[{"affinity":[0],"type":"memory","size":512}]}},
"checksum": 101010 "checksum": 101010
}`, }`,
@ -164,8 +164,8 @@ func TestCheckpointStateStore(t *testing.T) {
}, },
}, },
}, },
machineState: NodeMap{ machineState: NUMANodeMap{
0: &NodeState{ 0: &NUMANodeState{
MemoryMap: map[v1.ResourceName]*MemoryTable{ MemoryMap: map[v1.ResourceName]*MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536, Allocatable: 1536,
@ -208,7 +208,7 @@ func TestCheckpointStateStore(t *testing.T) {
func TestCheckpointStateHelpers(t *testing.T) { func TestCheckpointStateHelpers(t *testing.T) {
testCases := []struct { testCases := []struct {
description string description string
machineState NodeMap machineState NUMANodeMap
assignments ContainerMemoryAssignments assignments ContainerMemoryAssignments
}{ }{
{ {
@ -224,8 +224,8 @@ func TestCheckpointStateHelpers(t *testing.T) {
}, },
}, },
}, },
machineState: NodeMap{ machineState: NUMANodeMap{
0: &NodeState{ 0: &NUMANodeState{
MemoryMap: map[v1.ResourceName]*MemoryTable{ MemoryMap: map[v1.ResourceName]*MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536, Allocatable: 1536,
@ -235,7 +235,7 @@ func TestCheckpointStateHelpers(t *testing.T) {
TotalMemSize: 2048, TotalMemSize: 2048,
}, },
}, },
Nodes: []int{}, Cells: []int{},
}, },
}, },
}, },
@ -259,8 +259,8 @@ func TestCheckpointStateHelpers(t *testing.T) {
}, },
}, },
}, },
machineState: NodeMap{ machineState: NUMANodeMap{
0: &NodeState{ 0: &NUMANodeState{
MemoryMap: map[v1.ResourceName]*MemoryTable{ MemoryMap: map[v1.ResourceName]*MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536, Allocatable: 1536,
@ -270,7 +270,7 @@ func TestCheckpointStateHelpers(t *testing.T) {
TotalMemSize: 2048, TotalMemSize: 2048,
}, },
}, },
Nodes: []int{}, Cells: []int{},
}, },
}, },
}, },
@ -281,8 +281,8 @@ func TestCheckpointStateHelpers(t *testing.T) {
"container1": {}, "container1": {},
}, },
}, },
machineState: NodeMap{ machineState: NUMANodeMap{
0: &NodeState{ 0: &NUMANodeState{
MemoryMap: map[v1.ResourceName]*MemoryTable{ MemoryMap: map[v1.ResourceName]*MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536, Allocatable: 1536,
@ -292,7 +292,7 @@ func TestCheckpointStateHelpers(t *testing.T) {
TotalMemSize: 2048, TotalMemSize: 2048,
}, },
}, },
Nodes: []int{}, Cells: []int{},
}, },
}, },
}, },
@ -335,7 +335,7 @@ func TestCheckpointStateHelpers(t *testing.T) {
func TestCheckpointStateClear(t *testing.T) { func TestCheckpointStateClear(t *testing.T) {
testCases := []struct { testCases := []struct {
description string description string
machineState NodeMap machineState NUMANodeMap
assignments ContainerMemoryAssignments assignments ContainerMemoryAssignments
}{ }{
{ {
@ -351,8 +351,8 @@ func TestCheckpointStateClear(t *testing.T) {
}, },
}, },
}, },
machineState: NodeMap{ machineState: NUMANodeMap{
0: &NodeState{ 0: &NUMANodeState{
MemoryMap: map[v1.ResourceName]*MemoryTable{ MemoryMap: map[v1.ResourceName]*MemoryTable{
v1.ResourceMemory: { v1.ResourceMemory: {
Allocatable: 1536, Allocatable: 1536,
@ -383,7 +383,7 @@ func TestCheckpointStateClear(t *testing.T) {
state.SetMemoryAssignments(tc.assignments) state.SetMemoryAssignments(tc.assignments)
state.ClearState() state.ClearState()
assert.Equal(t, NodeMap{}, state.GetMachineState(), "cleared state with non-empty machine state") assert.Equal(t, NUMANodeMap{}, state.GetMachineState(), "cleared state with non-empty machine state")
assert.Equal(t, ContainerMemoryAssignments{}, state.GetMemoryAssignments(), "cleared state with non-empty memory assignments") assert.Equal(t, ContainerMemoryAssignments{}, state.GetMemoryAssignments(), "cleared state with non-empty memory assignments")
}) })
} }

12
pkg/kubelet/cm/memorymanager/state/state_mem.go
View File

@ -25,7 +25,7 @@ import (
type stateMemory struct { type stateMemory struct {
sync.RWMutex sync.RWMutex
assignments ContainerMemoryAssignments assignments ContainerMemoryAssignments
machineState NodeMap machineState NUMANodeMap
} }
var _ State = &stateMemory{} var _ State = &stateMemory{}
@ -35,12 +35,12 @@ func NewMemoryState() State {
klog.Infof("[memorymanager] initializing new in-memory state store") klog.Infof("[memorymanager] initializing new in-memory state store")
return &stateMemory{ return &stateMemory{
assignments: ContainerMemoryAssignments{}, assignments: ContainerMemoryAssignments{},
machineState: NodeMap{}, machineState: NUMANodeMap{},
} }
} }
// GetMemoryState returns Memory Map stored in the State // GetMemoryState returns Memory Map stored in the State
func (s *stateMemory) GetMachineState() NodeMap { func (s *stateMemory) GetMachineState() NUMANodeMap {
s.RLock() s.RLock()
defer s.RUnlock() defer s.RUnlock()
@ -66,8 +66,8 @@ func (s *stateMemory) GetMemoryAssignments() ContainerMemoryAssignments {
return s.assignments.Clone() return s.assignments.Clone()
} }
// SetMachineState stores NodeMap in State // SetMachineState stores NUMANodeMap in State
func (s *stateMemory) SetMachineState(nodeMap NodeMap) { func (s *stateMemory) SetMachineState(nodeMap NUMANodeMap) {
s.Lock() s.Lock()
defer s.Unlock() defer s.Unlock()
@ -117,7 +117,7 @@ func (s *stateMemory) ClearState() {
s.Lock() s.Lock()
defer s.Unlock() defer s.Unlock()
s.machineState = NodeMap{} s.machineState = NUMANodeMap{}
s.assignments = make(ContainerMemoryAssignments) s.assignments = make(ContainerMemoryAssignments)
klog.V(2).Infof("[memorymanager] cleared state") klog.V(2).Infof("[memorymanager] cleared state")
} }