Merge pull request kubernetes#129684 from swatisehgal/mm-mgr-logs-improvements

k8s-ci-robot · web-flow · commit e094e5e89c85 · 2025-02-07T03:49:55.000-08:00
Memory Manager logging improvements
diff --git a/pkg/kubelet/cm/memorymanager/memory_manager.go b/pkg/kubelet/cm/memorymanager/memory_manager.go
@@ -205,6 +205,7 @@ func (m *manager) Start(activePods ActivePodsFunc, sourcesReady config.SourcesRe
 
 	m.allocatableMemory = m.policy.GetAllocatableMemory(m.state)
 
+	klog.V(4).InfoS("memorymanager started", "policy", m.policy.Name())
 	return nil
 }
 
@@ -248,7 +249,7 @@ func (m *manager) GetMemoryNUMANodes(pod *v1.Pod, container *v1.Container) sets.
 	}
 
 	if numaNodes.Len() == 0 {
-		klog.V(5).InfoS("No allocation is available", "pod", klog.KObj(pod), "containerName", container.Name)
+		klog.V(5).InfoS("NUMA nodes not available for allocation", "pod", klog.KObj(pod), "containerName", container.Name)
 		return nil
 	}
 
@@ -266,7 +267,7 @@ func (m *manager) Allocate(pod *v1.Pod, container *v1.Container) error {
 
 	// Call down into the policy to assign this container memory if required.
 	if err := m.policy.Allocate(m.state, pod, container); err != nil {
-		klog.ErrorS(err, "Allocate error")
+		klog.ErrorS(err, "Allocate error", "pod", klog.KObj(pod), "containerName", container.Name)
 		return err
 	}
 	return nil
@@ -280,7 +281,7 @@ func (m *manager) RemoveContainer(containerID string) error {
 	// if error appears it means container entry already does not exist under the container map
 	podUID, containerName, err := m.containerMap.GetContainerRef(containerID)
 	if err != nil {
-		klog.InfoS("Failed to get container from container map", "containerID", containerID, "err", err)
+		klog.ErrorS(err, "Failed to get container from container map", "containerID", containerID)
 		return nil
 	}
 
@@ -344,15 +345,15 @@ func (m *manager) removeStaleState() {
 	for podUID := range assignments {
 		for containerName := range assignments[podUID] {
 			if _, ok := activeContainers[podUID][containerName]; !ok {
-				klog.InfoS("RemoveStaleState removing state", "podUID", podUID, "containerName", containerName)
+				klog.V(2).InfoS("RemoveStaleState removing state", "podUID", podUID, "containerName", containerName)
 				m.policyRemoveContainerByRef(podUID, containerName)
 			}
 		}
 	}
 
 	m.containerMap.Visit(func(podUID, containerName, containerID string) {
 		if _, ok := activeContainers[podUID][containerName]; !ok {
-			klog.InfoS("RemoveStaleState removing state", "podUID", podUID, "containerName", containerName)
+			klog.V(2).InfoS("RemoveStaleState removing state", "podUID", podUID, "containerName", containerName)
 			m.policyRemoveContainerByRef(podUID, containerName)
 		}
 	})
diff --git a/pkg/kubelet/cm/memorymanager/policy_static.go b/pkg/kubelet/cm/memorymanager/policy_static.go
@@ -96,7 +96,9 @@ func (p *staticPolicy) Start(s state.State) error {
 // Allocate call is idempotent
 func (p *staticPolicy) Allocate(s state.State, pod *v1.Pod, container *v1.Container) (rerr error) {
 	// allocate the memory only for guaranteed pods
-	if v1qos.GetPodQOS(pod) != v1.PodQOSGuaranteed {
+	qos := v1qos.GetPodQOS(pod)
+	if qos != v1.PodQOSGuaranteed {
+		klog.V(5).InfoS("Exclusive memory allocation skipped, pod QoS is not guaranteed", "pod", klog.KObj(pod), "containerName", container.Name, "qos", qos)
 		return nil
 	}
 
@@ -196,6 +198,7 @@ func (p *staticPolicy) Allocate(s state.State, pod *v1.Pod, container *v1.Contai
 	// TODO: we should refactor our state structs to reflect the amount of the re-used memory
 	p.updateInitContainersMemoryBlocks(s, pod, container, containerBlocks)
 
+	klog.V(4).InfoS("Allocated exclusive memory", "pod", klog.KObj(pod), "containerName", container.Name)
 	return nil
 }
 
@@ -304,24 +307,24 @@ func regenerateHints(pod *v1.Pod, ctn *v1.Container, ctnBlocks []state.Block, re
 	}
 
 	if len(ctnBlocks) != len(reqRsrc) {
-		klog.ErrorS(nil, "The number of requested resources by the container differs from the number of memory blocks", "containerName", ctn.Name)
+		klog.InfoS("The number of requested resources by the container differs from the number of memory blocks", "pod", klog.KObj(pod), "containerName", ctn.Name)
 		return nil
 	}
 
 	for _, b := range ctnBlocks {
 		if _, ok := reqRsrc[b.Type]; !ok {
-			klog.ErrorS(nil, "Container requested resources do not have resource of this type", "containerName", ctn.Name, "type", b.Type)
+			klog.InfoS("Container requested resources but none available of this type", "pod", klog.KObj(pod), "containerName", ctn.Name, "type", b.Type)
 			return nil
 		}
 
 		if b.Size != reqRsrc[b.Type] {
-			klog.ErrorS(nil, "Memory already allocated with different numbers than requested", "podUID", pod.UID, "type", b.Type, "containerName", ctn.Name, "requestedResource", reqRsrc[b.Type], "allocatedSize", b.Size)
+			klog.InfoS("Memory already allocated with different numbers than requested", "pod", klog.KObj(pod), "containerName", ctn.Name, "type", b.Type, "requestedResource", reqRsrc[b.Type], "allocatedSize", b.Size)
 			return nil
 		}
 
 		containerNUMAAffinity, err := bitmask.NewBitMask(b.NUMAAffinity...)
 		if err != nil {
-			klog.ErrorS(err, "Failed to generate NUMA bitmask")
+			klog.ErrorS(err, "Failed to generate NUMA bitmask", "pod", klog.KObj(pod), "containerName", ctn.Name, "type", b.Type)
 			return nil
 		}
 
@@ -660,36 +663,36 @@ func (p *staticPolicy) validateState(s state.State) error {
 
 func areMachineStatesEqual(ms1, ms2 state.NUMANodeMap) bool {
 	if len(ms1) != len(ms2) {
-		klog.ErrorS(nil, "Node states are different", "lengthNode1", len(ms1), "lengthNode2", len(ms2))
+		klog.InfoS("Node states were different", "lengthNode1", len(ms1), "lengthNode2", len(ms2))
 		return false
 	}
 
 	for nodeID, nodeState1 := range ms1 {
 		nodeState2, ok := ms2[nodeID]
 		if !ok {
-			klog.ErrorS(nil, "Node state does not have node ID", "nodeID", nodeID)
+			klog.InfoS("Node state didn't have node ID", "nodeID", nodeID)
 			return false
 		}
 
 		if nodeState1.NumberOfAssignments != nodeState2.NumberOfAssignments {
-			klog.ErrorS(nil, "Node states number of assignments are different", "assignment1", nodeState1.NumberOfAssignments, "assignment2", nodeState2.NumberOfAssignments)
+			klog.InfoS("Node state had a different number of memory assignments.", "assignment1", nodeState1.NumberOfAssignments, "assignment2", nodeState2.NumberOfAssignments)
 			return false
 		}
 
 		if !areGroupsEqual(nodeState1.Cells, nodeState2.Cells) {
-			klog.ErrorS(nil, "Node states groups are different", "stateNode1", nodeState1.Cells, "stateNode2", nodeState2.Cells)
+			klog.InfoS("Node states had different groups", "stateNode1", nodeState1.Cells, "stateNode2", nodeState2.Cells)
 			return false
 		}
 
 		if len(nodeState1.MemoryMap) != len(nodeState2.MemoryMap) {
-			klog.ErrorS(nil, "Node states memory map have different lengths", "lengthNode1", len(nodeState1.MemoryMap), "lengthNode2", len(nodeState2.MemoryMap))
+			klog.InfoS("Node state had memory maps of different lengths", "lengthNode1", len(nodeState1.MemoryMap), "lengthNode2", len(nodeState2.MemoryMap))
 			return false
 		}
 
 		for resourceName, memoryState1 := range nodeState1.MemoryMap {
 			memoryState2, ok := nodeState2.MemoryMap[resourceName]
 			if !ok {
-				klog.ErrorS(nil, "Memory state does not have resource", "resource", resourceName)
+				klog.InfoS("Memory state didn't have resource", "resource", resourceName)
 				return false
 			}
 
@@ -707,11 +710,11 @@ func areMachineStatesEqual(ms1, ms2 state.NUMANodeMap) bool {
 			}
 
 			if tmpState1.Free != tmpState2.Free {
-				klog.InfoS("Memory states for the NUMA node and resource are different", "node", nodeID, "resource", resourceName, "field", "free", "free1", tmpState1.Free, "free2", tmpState2.Free, "memoryState1", *memoryState1, "memoryState2", *memoryState2)
+				klog.InfoS("NUMA node and resource had different memory states", "node", nodeID, "resource", resourceName, "field", "free", "free1", tmpState1.Free, "free2", tmpState2.Free, "memoryState1", *memoryState1, "memoryState2", *memoryState2)
 				return false
 			}
 			if tmpState1.Reserved != tmpState2.Reserved {
-				klog.InfoS("Memory states for the NUMA node and resource are different", "node", nodeID, "resource", resourceName, "field", "reserved", "reserved1", tmpState1.Reserved, "reserved2", tmpState2.Reserved, "memoryState1", *memoryState1, "memoryState2", *memoryState2)
+				klog.InfoS("NUMA node and resource had different memory states", "node", nodeID, "resource", resourceName, "field", "reserved", "reserved1", tmpState1.Reserved, "reserved2", tmpState2.Reserved, "memoryState1", *memoryState1, "memoryState2", *memoryState2)
 				return false
 			}
 		}
@@ -721,17 +724,17 @@ func areMachineStatesEqual(ms1, ms2 state.NUMANodeMap) bool {
 
 func areMemoryStatesEqual(memoryState1, memoryState2 *state.MemoryTable, nodeID int, resourceName v1.ResourceName) bool {
 	if memoryState1.TotalMemSize != memoryState2.TotalMemSize {
-		klog.ErrorS(nil, "Memory states for the NUMA node and resource are different", "node", nodeID, "resource", resourceName, "field", "TotalMemSize", "TotalMemSize1", memoryState1.TotalMemSize, "TotalMemSize2", memoryState2.TotalMemSize, "memoryState1", *memoryState1, "memoryState2", *memoryState2)
+		klog.InfoS("Memory states for the NUMA node and resource are different", "node", nodeID, "resource", resourceName, "field", "TotalMemSize", "TotalMemSize1", memoryState1.TotalMemSize, "TotalMemSize2", memoryState2.TotalMemSize, "memoryState1", *memoryState1, "memoryState2", *memoryState2)
 		return false
 	}
 
 	if memoryState1.SystemReserved != memoryState2.SystemReserved {
-		klog.ErrorS(nil, "Memory states for the NUMA node and resource are different", "node", nodeID, "resource", resourceName, "field", "SystemReserved", "SystemReserved1", memoryState1.SystemReserved, "SystemReserved2", memoryState2.SystemReserved, "memoryState1", *memoryState1, "memoryState2", *memoryState2)
+		klog.InfoS("Memory states for the NUMA node and resource are different", "node", nodeID, "resource", resourceName, "field", "SystemReserved", "SystemReserved1", memoryState1.SystemReserved, "SystemReserved2", memoryState2.SystemReserved, "memoryState1", *memoryState1, "memoryState2", *memoryState2)
 		return false
 	}
 
 	if memoryState1.Allocatable != memoryState2.Allocatable {
-		klog.ErrorS(nil, "Memory states for the NUMA node and resource are different", "node", nodeID, "resource", resourceName, "field", "Allocatable", "Allocatable1", memoryState1.Allocatable, "Allocatable2", memoryState2.Allocatable, "memoryState1", *memoryState1, "memoryState2", *memoryState2)
+		klog.InfoS("Memory states for the NUMA node and resource are different", "node", nodeID, "resource", resourceName, "field", "Allocatable", "Allocatable1", memoryState1.Allocatable, "Allocatable2", memoryState2.Allocatable, "memoryState1", *memoryState1, "memoryState2", *memoryState2)
 		return false
 	}
 	return true
diff --git a/pkg/kubelet/cm/memorymanager/state/state_checkpoint.go b/pkg/kubelet/cm/memorymanager/state/state_checkpoint.go
@@ -131,7 +131,7 @@ func (sc *stateCheckpoint) SetMachineState(memoryMap NUMANodeMap) {
 	sc.cache.SetMachineState(memoryMap)
 	err := sc.storeState()
 	if err != nil {
-		klog.InfoS("Store state to checkpoint error", "err", err)
+		klog.ErrorS(err, "Failed to store state to checkpoint")
 	}
 }
 
@@ -143,7 +143,7 @@ func (sc *stateCheckpoint) SetMemoryBlocks(podUID string, containerName string,
 	sc.cache.SetMemoryBlocks(podUID, containerName, blocks)
 	err := sc.storeState()
 	if err != nil {
-		klog.InfoS("Store state to checkpoint error", "err", err)
+		klog.ErrorS(err, "Failed to store state to checkpoint", "podUID", podUID, "containerName", containerName)
 	}
 }
 
@@ -155,7 +155,7 @@ func (sc *stateCheckpoint) SetMemoryAssignments(assignments ContainerMemoryAssig
 	sc.cache.SetMemoryAssignments(assignments)
 	err := sc.storeState()
 	if err != nil {
-		klog.InfoS("Store state to checkpoint error", "err", err)
+		klog.ErrorS(err, "Failed to store state to checkpoint")
 	}
 }
 
@@ -167,7 +167,7 @@ func (sc *stateCheckpoint) Delete(podUID string, containerName string) {
 	sc.cache.Delete(podUID, containerName)
 	err := sc.storeState()
 	if err != nil {
-		klog.InfoS("Store state to checkpoint error", "err", err)
+		klog.ErrorS(err, "Failed to store state to checkpoint", "podUID", podUID, "containerName", containerName)
 	}
 }
 
@@ -179,6 +179,6 @@ func (sc *stateCheckpoint) ClearState() {
 	sc.cache.ClearState()
 	err := sc.storeState()
 	if err != nil {
-		klog.InfoS("Store state to checkpoint error", "err", err)
+		klog.ErrorS(err, "Failed to store state to checkpoint")
 	}
 }
diff --git a/pkg/kubelet/cm/memorymanager/state/state_mem.go b/pkg/kubelet/cm/memorymanager/state/state_mem.go
@@ -94,6 +94,7 @@ func (s *stateMemory) SetMemoryAssignments(assignments ContainerMemoryAssignment
 	defer s.Unlock()
 
 	s.assignments = assignments.Clone()
+	klog.V(5).InfoS("Updated Memory assignments", "assignments", assignments)
 }
 
 // Delete deletes corresponding Blocks from ContainerMemoryAssignments

Original file line number	Diff line number	Diff line change
`@@ -205,6 +205,7 @@ func (m *manager) Start(activePods ActivePodsFunc, sourcesReady config.SourcesRe`
`205`	`205`
`206`	`206`	`m.allocatableMemory = m.policy.GetAllocatableMemory(m.state)`
`207`	`207`
	`208`	`+ klog.V(4).InfoS("memorymanager started", "policy", m.policy.Name())`
`208`	`209`	`return nil`
`209`	`210`	`}`
`210`	`211`
`@@ -248,7 +249,7 @@ func (m manager) GetMemoryNUMANodes(pod v1.Pod, container *v1.Container) sets.`
`248`	`249`	`}`
`249`	`250`
`250`	`251`	`if numaNodes.Len() == 0 {`
`251`		`- klog.V(5).InfoS("No allocation is available", "pod", klog.KObj(pod), "containerName", container.Name)`
	`252`	`+ klog.V(5).InfoS("NUMA nodes not available for allocation", "pod", klog.KObj(pod), "containerName", container.Name)`
`252`	`253`	`return nil`
`253`	`254`	`}`
`254`	`255`
`@@ -266,7 +267,7 @@ func (m manager) Allocate(pod v1.Pod, container *v1.Container) error {`
`266`	`267`
`267`	`268`	`// Call down into the policy to assign this container memory if required.`
`268`	`269`	`if err := m.policy.Allocate(m.state, pod, container); err != nil {`
`269`		`- klog.ErrorS(err, "Allocate error")`
	`270`	`+ klog.ErrorS(err, "Allocate error", "pod", klog.KObj(pod), "containerName", container.Name)`
`270`	`271`	`return err`
`271`	`272`	`}`
`272`	`273`	`return nil`
`@@ -280,7 +281,7 @@ func (m *manager) RemoveContainer(containerID string) error {`
`280`	`281`	`// if error appears it means container entry already does not exist under the container map`
`281`	`282`	`podUID, containerName, err := m.containerMap.GetContainerRef(containerID)`
`282`	`283`	`if err != nil {`
`283`		`- klog.InfoS("Failed to get container from container map", "containerID", containerID, "err", err)`
	`284`	`+ klog.ErrorS(err, "Failed to get container from container map", "containerID", containerID)`
`284`	`285`	`return nil`
`285`	`286`	`}`
`286`	`287`
`@@ -344,15 +345,15 @@ func (m *manager) removeStaleState() {`
`344`	`345`	`for podUID := range assignments {`
`345`	`346`	`for containerName := range assignments[podUID] {`
`346`	`347`	`if _, ok := activeContainers[podUID][containerName]; !ok {`
`347`		`- klog.InfoS("RemoveStaleState removing state", "podUID", podUID, "containerName", containerName)`
	`348`	`+ klog.V(2).InfoS("RemoveStaleState removing state", "podUID", podUID, "containerName", containerName)`
`348`	`349`	`m.policyRemoveContainerByRef(podUID, containerName)`
`349`	`350`	`}`
`350`	`351`	`}`
`351`	`352`	`}`
`352`	`353`
`353`	`354`	`m.containerMap.Visit(func(podUID, containerName, containerID string) {`
`354`	`355`	`if _, ok := activeContainers[podUID][containerName]; !ok {`
`355`		`- klog.InfoS("RemoveStaleState removing state", "podUID", podUID, "containerName", containerName)`
	`356`	`+ klog.V(2).InfoS("RemoveStaleState removing state", "podUID", podUID, "containerName", containerName)`
`356`	`357`	`m.policyRemoveContainerByRef(podUID, containerName)`
`357`	`358`	`}`
`358`	`359`	`})`
Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,9 @@ func (p *staticPolicy) Start(s state.State) error {`
`96`	`96`	`// Allocate call is idempotent`
`97`	`97`	`func (p staticPolicy) Allocate(s state.State, pod v1.Pod, container *v1.Container) (rerr error) {`
`98`	`98`	`// allocate the memory only for guaranteed pods`
`99`		`- if v1qos.GetPodQOS(pod) != v1.PodQOSGuaranteed {`
	`99`	`+ qos := v1qos.GetPodQOS(pod)`
	`100`	`+ if qos != v1.PodQOSGuaranteed {`
	`101`	`+ klog.V(5).InfoS("Exclusive memory allocation skipped, pod QoS is not guaranteed", "pod", klog.KObj(pod), "containerName", container.Name, "qos", qos)`
`100`	`102`	`return nil`
`101`	`103`	`}`
`102`	`104`
`@@ -196,6 +198,7 @@ func (p staticPolicy) Allocate(s state.State, pod v1.Pod, container *v1.Contai`
`196`	`198`	`// TODO: we should refactor our state structs to reflect the amount of the re-used memory`
`197`	`199`	`p.updateInitContainersMemoryBlocks(s, pod, container, containerBlocks)`
`198`	`200`
	`201`	`+ klog.V(4).InfoS("Allocated exclusive memory", "pod", klog.KObj(pod), "containerName", container.Name)`
`199`	`202`	`return nil`
`200`	`203`	`}`
`201`	`204`
`@@ -304,24 +307,24 @@ func regenerateHints(pod v1.Pod, ctn v1.Container, ctnBlocks []state.Block, re`
`304`	`307`	`}`
`305`	`308`
`306`	`309`	`if len(ctnBlocks) != len(reqRsrc) {`
`307`		`- klog.ErrorS(nil, "The number of requested resources by the container differs from the number of memory blocks", "containerName", ctn.Name)`
	`310`	`+ klog.InfoS("The number of requested resources by the container differs from the number of memory blocks", "pod", klog.KObj(pod), "containerName", ctn.Name)`
`308`	`311`	`return nil`
`309`	`312`	`}`
`310`	`313`
`311`	`314`	`for _, b := range ctnBlocks {`
`312`	`315`	`if _, ok := reqRsrc[b.Type]; !ok {`
`313`		`- klog.ErrorS(nil, "Container requested resources do not have resource of this type", "containerName", ctn.Name, "type", b.Type)`
	`316`	`+ klog.InfoS("Container requested resources but none available of this type", "pod", klog.KObj(pod), "containerName", ctn.Name, "type", b.Type)`
`314`	`317`	`return nil`
`315`	`318`	`}`
`316`	`319`
`317`	`320`	`if b.Size != reqRsrc[b.Type] {`
`318`		`- klog.ErrorS(nil, "Memory already allocated with different numbers than requested", "podUID", pod.UID, "type", b.Type, "containerName", ctn.Name, "requestedResource", reqRsrc[b.Type], "allocatedSize", b.Size)`
	`321`	`+ klog.InfoS("Memory already allocated with different numbers than requested", "pod", klog.KObj(pod), "containerName", ctn.Name, "type", b.Type, "requestedResource", reqRsrc[b.Type], "allocatedSize", b.Size)`
`319`	`322`	`return nil`
`320`	`323`	`}`
`321`	`324`
`322`	`325`	`containerNUMAAffinity, err := bitmask.NewBitMask(b.NUMAAffinity...)`
`323`	`326`	`if err != nil {`
`324`		`- klog.ErrorS(err, "Failed to generate NUMA bitmask")`
	`327`	`+ klog.ErrorS(err, "Failed to generate NUMA bitmask", "pod", klog.KObj(pod), "containerName", ctn.Name, "type", b.Type)`
`325`	`328`	`return nil`
`326`	`329`	`}`
`327`	`330`
`@@ -660,36 +663,36 @@ func (p *staticPolicy) validateState(s state.State) error {`
`660`	`663`
`661`	`664`	`func areMachineStatesEqual(ms1, ms2 state.NUMANodeMap) bool {`
`662`	`665`	`if len(ms1) != len(ms2) {`
`663`		`- klog.ErrorS(nil, "Node states are different", "lengthNode1", len(ms1), "lengthNode2", len(ms2))`
	`666`	`+ klog.InfoS("Node states were different", "lengthNode1", len(ms1), "lengthNode2", len(ms2))`
`664`	`667`	`return false`
`665`	`668`	`}`
`666`	`669`
`667`	`670`	`for nodeID, nodeState1 := range ms1 {`
`668`	`671`	`nodeState2, ok := ms2[nodeID]`
`669`	`672`	`if !ok {`
`670`		`- klog.ErrorS(nil, "Node state does not have node ID", "nodeID", nodeID)`
	`673`	`+ klog.InfoS("Node state didn't have node ID", "nodeID", nodeID)`
`671`	`674`	`return false`
`672`	`675`	`}`
`673`	`676`
`674`	`677`	`if nodeState1.NumberOfAssignments != nodeState2.NumberOfAssignments {`
`675`		`- klog.ErrorS(nil, "Node states number of assignments are different", "assignment1", nodeState1.NumberOfAssignments, "assignment2", nodeState2.NumberOfAssignments)`
	`678`	`+ klog.InfoS("Node state had a different number of memory assignments.", "assignment1", nodeState1.NumberOfAssignments, "assignment2", nodeState2.NumberOfAssignments)`
`676`	`679`	`return false`
`677`	`680`	`}`
`678`	`681`
`679`	`682`	`if !areGroupsEqual(nodeState1.Cells, nodeState2.Cells) {`
`680`		`- klog.ErrorS(nil, "Node states groups are different", "stateNode1", nodeState1.Cells, "stateNode2", nodeState2.Cells)`
	`683`	`+ klog.InfoS("Node states had different groups", "stateNode1", nodeState1.Cells, "stateNode2", nodeState2.Cells)`
`681`	`684`	`return false`
`682`	`685`	`}`
`683`	`686`
`684`	`687`	`if len(nodeState1.MemoryMap) != len(nodeState2.MemoryMap) {`
`685`		`- klog.ErrorS(nil, "Node states memory map have different lengths", "lengthNode1", len(nodeState1.MemoryMap), "lengthNode2", len(nodeState2.MemoryMap))`
	`688`	`+ klog.InfoS("Node state had memory maps of different lengths", "lengthNode1", len(nodeState1.MemoryMap), "lengthNode2", len(nodeState2.MemoryMap))`
`686`	`689`	`return false`
`687`	`690`	`}`
`688`	`691`
`689`	`692`	`for resourceName, memoryState1 := range nodeState1.MemoryMap {`
`690`	`693`	`memoryState2, ok := nodeState2.MemoryMap[resourceName]`
`691`	`694`	`if !ok {`
`692`		`- klog.ErrorS(nil, "Memory state does not have resource", "resource", resourceName)`
	`695`	`+ klog.InfoS("Memory state didn't have resource", "resource", resourceName)`
`693`	`696`	`return false`
`694`	`697`	`}`
`695`	`698`
`@@ -707,11 +710,11 @@ func areMachineStatesEqual(ms1, ms2 state.NUMANodeMap) bool {`
`707`	`710`	`}`
`708`	`711`
`709`	`712`	`if tmpState1.Free != tmpState2.Free {`
`710`		`- klog.InfoS("Memory states for the NUMA node and resource are different", "node", nodeID, "resource", resourceName, "field", "free", "free1", tmpState1.Free, "free2", tmpState2.Free, "memoryState1", memoryState1, "memoryState2", memoryState2)`
	`713`	`+ klog.InfoS("NUMA node and resource had different memory states", "node", nodeID, "resource", resourceName, "field", "free", "free1", tmpState1.Free, "free2", tmpState2.Free, "memoryState1", memoryState1, "memoryState2", memoryState2)`
`711`	`714`	`return false`
`712`	`715`	`}`
`713`	`716`	`if tmpState1.Reserved != tmpState2.Reserved {`
`714`		`- klog.InfoS("Memory states for the NUMA node and resource are different", "node", nodeID, "resource", resourceName, "field", "reserved", "reserved1", tmpState1.Reserved, "reserved2", tmpState2.Reserved, "memoryState1", memoryState1, "memoryState2", memoryState2)`
	`717`	`+ klog.InfoS("NUMA node and resource had different memory states", "node", nodeID, "resource", resourceName, "field", "reserved", "reserved1", tmpState1.Reserved, "reserved2", tmpState2.Reserved, "memoryState1", memoryState1, "memoryState2", memoryState2)`
`715`	`718`	`return false`
`716`	`719`	`}`
`717`	`720`	`}`
`@@ -721,17 +724,17 @@ func areMachineStatesEqual(ms1, ms2 state.NUMANodeMap) bool {`
`721`	`724`
`722`	`725`	`func areMemoryStatesEqual(memoryState1, memoryState2 *state.MemoryTable, nodeID int, resourceName v1.ResourceName) bool {`
`723`	`726`	`if memoryState1.TotalMemSize != memoryState2.TotalMemSize {`
`724`		`- klog.ErrorS(nil, "Memory states for the NUMA node and resource are different", "node", nodeID, "resource", resourceName, "field", "TotalMemSize", "TotalMemSize1", memoryState1.TotalMemSize, "TotalMemSize2", memoryState2.TotalMemSize, "memoryState1", memoryState1, "memoryState2", memoryState2)`
	`727`	`+ klog.InfoS("Memory states for the NUMA node and resource are different", "node", nodeID, "resource", resourceName, "field", "TotalMemSize", "TotalMemSize1", memoryState1.TotalMemSize, "TotalMemSize2", memoryState2.TotalMemSize, "memoryState1", memoryState1, "memoryState2", memoryState2)`
`725`	`728`	`return false`
`726`	`729`	`}`
`727`	`730`
`728`	`731`	`if memoryState1.SystemReserved != memoryState2.SystemReserved {`
`729`		`- klog.ErrorS(nil, "Memory states for the NUMA node and resource are different", "node", nodeID, "resource", resourceName, "field", "SystemReserved", "SystemReserved1", memoryState1.SystemReserved, "SystemReserved2", memoryState2.SystemReserved, "memoryState1", memoryState1, "memoryState2", memoryState2)`
	`732`	`+ klog.InfoS("Memory states for the NUMA node and resource are different", "node", nodeID, "resource", resourceName, "field", "SystemReserved", "SystemReserved1", memoryState1.SystemReserved, "SystemReserved2", memoryState2.SystemReserved, "memoryState1", memoryState1, "memoryState2", memoryState2)`
`730`	`733`	`return false`
`731`	`734`	`}`
`732`	`735`
`733`	`736`	`if memoryState1.Allocatable != memoryState2.Allocatable {`
`734`		`- klog.ErrorS(nil, "Memory states for the NUMA node and resource are different", "node", nodeID, "resource", resourceName, "field", "Allocatable", "Allocatable1", memoryState1.Allocatable, "Allocatable2", memoryState2.Allocatable, "memoryState1", memoryState1, "memoryState2", memoryState2)`
	`737`	`+ klog.InfoS("Memory states for the NUMA node and resource are different", "node", nodeID, "resource", resourceName, "field", "Allocatable", "Allocatable1", memoryState1.Allocatable, "Allocatable2", memoryState2.Allocatable, "memoryState1", memoryState1, "memoryState2", memoryState2)`
`735`	`738`	`return false`
`736`	`739`	`}`
`737`	`740`	`return true`
Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ func (sc *stateCheckpoint) SetMachineState(memoryMap NUMANodeMap) {`
`131`	`131`	`sc.cache.SetMachineState(memoryMap)`
`132`	`132`	`err := sc.storeState()`
`133`	`133`	`if err != nil {`
`134`		`- klog.InfoS("Store state to checkpoint error", "err", err)`
	`134`	`+ klog.ErrorS(err, "Failed to store state to checkpoint")`
`135`	`135`	`}`
`136`	`136`	`}`
`137`	`137`
`@@ -143,7 +143,7 @@ func (sc *stateCheckpoint) SetMemoryBlocks(podUID string, containerName string,`
`143`	`143`	`sc.cache.SetMemoryBlocks(podUID, containerName, blocks)`
`144`	`144`	`err := sc.storeState()`
`145`	`145`	`if err != nil {`
`146`		`- klog.InfoS("Store state to checkpoint error", "err", err)`
	`146`	`+ klog.ErrorS(err, "Failed to store state to checkpoint", "podUID", podUID, "containerName", containerName)`
`147`	`147`	`}`
`148`	`148`	`}`
`149`	`149`
`@@ -155,7 +155,7 @@ func (sc *stateCheckpoint) SetMemoryAssignments(assignments ContainerMemoryAssig`
`155`	`155`	`sc.cache.SetMemoryAssignments(assignments)`
`156`	`156`	`err := sc.storeState()`
`157`	`157`	`if err != nil {`
`158`		`- klog.InfoS("Store state to checkpoint error", "err", err)`
	`158`	`+ klog.ErrorS(err, "Failed to store state to checkpoint")`
`159`	`159`	`}`
`160`	`160`	`}`
`161`	`161`
`@@ -167,7 +167,7 @@ func (sc *stateCheckpoint) Delete(podUID string, containerName string) {`
`167`	`167`	`sc.cache.Delete(podUID, containerName)`
`168`	`168`	`err := sc.storeState()`
`169`	`169`	`if err != nil {`
`170`		`- klog.InfoS("Store state to checkpoint error", "err", err)`
	`170`	`+ klog.ErrorS(err, "Failed to store state to checkpoint", "podUID", podUID, "containerName", containerName)`
`171`	`171`	`}`
`172`	`172`	`}`
`173`	`173`
`@@ -179,6 +179,6 @@ func (sc *stateCheckpoint) ClearState() {`
`179`	`179`	`sc.cache.ClearState()`
`180`	`180`	`err := sc.storeState()`
`181`	`181`	`if err != nil {`
`182`		`- klog.InfoS("Store state to checkpoint error", "err", err)`
	`182`	`+ klog.ErrorS(err, "Failed to store state to checkpoint")`
`183`	`183`	`}`
`184`	`184`	`}`
Original file line number	Diff line number	Diff line change
`@@ -94,6 +94,7 @@ func (s *stateMemory) SetMemoryAssignments(assignments ContainerMemoryAssignment`
`94`	`94`	`defer s.Unlock()`
`95`	`95`
`96`	`96`	`s.assignments = assignments.Clone()`
	`97`	`+ klog.V(5).InfoS("Updated Memory assignments", "assignments", assignments)`
`97`	`98`	`}`
`98`	`99`
`99`	`100`	`// Delete deletes corresponding Blocks from ContainerMemoryAssignments`