},
		},
		Status: api.PersistentVolumeClaimStatus{
			Capacity: api.ResourceList{
				api.ResourceStorage: resource.MustParse(allocatedResources),
			},
			Phase: api.ClaimBound,
			AllocatedResources: api.ResourceList{
				api.ResourceStorage: resource.MustParse(allocatedResources),
			},
		},
	}
	if resizeStatus != nil {
		claimStatusMap := map[api.ResourceName]api.ClaimResourceStatus{

		// AllocatedResources values come from checkpoint. It is the source-of-truth.
		found := false
		status.AllocatedResources, found = kl.statusManager.GetContainerResourceAllocation(string(pod.UID), cName)
		if !(container.Resources.Requests == nil && container.Resources.Limits == nil) && !found {
			// Log error and fallback to AllocatedResources in oldStatus if it exists

// updateContainerResourceAllocation updates AllocatedResources values
// (for cpu & memory) from checkpoint store
func (kl *Kubelet) updateContainerResourceAllocation(pod *v1.Pod) {
	for _, c := range pod.Spec.Containers {
		allocatedResources, found := kl.statusManager.GetContainerResourceAllocation(string(pod.UID), c.Name)
		if c.Resources.Requests != nil && found {
			if _, ok := allocatedResources[v1.ResourceCPU]; ok {

						{
							Name:               "c1",
							Image:              "image",
							AllocatedResources: api.ResourceList{api.ResourceCPU: resource.MustParse("100m")},
						},
						{
							Name:               "c2",
							Image:              "image",
							AllocatedResources: api.ResourceList{api.ResourceCPU: resource.MustParse("200m")},
						},
					},
				},
			},

			cs, found := containerStatuses[container.Name]
			if found {
				if pod.Status.Resize == api.PodResizeStatusInfeasible {
					containerReqs = cs.AllocatedResources
				} else {
					containerReqs = max(container.Resources.Requests, cs.AllocatedResources)
				}
			}
		}

		addResourceList(reqs, containerReqs)
	}

	restartableInitCotnainerReqs := api.ResourceList{}

	}

	if !utilfeature.DefaultFeatureGate.Enabled(features.InPlacePodVerticalScaling) && !inPlacePodVerticalScalingInUse(oldPodSpec) {
		// Drop Resize, AllocatedResources, and Resources fields
		dropResourcesFields := func(csl []api.ContainerStatus) {
			for i := range csl {
				csl[i].AllocatedResources = nil
				csl[i].Resources = nil
			}
		}
		dropResourcesFields(podStatus.ContainerStatuses)

		newPVC.Status.Conditions = nil

		if p.expansionRecoveryEnabled {
			oldPVC.Status.AllocatedResourceStatuses = nil
			newPVC.Status.AllocatedResourceStatuses = nil

			oldPVC.Status.AllocatedResources = nil
			newPVC.Status.AllocatedResources = nil
		}

		// TODO(apelisse): We don't have a good mechanism to
		// verify that only the things that should have changed
		// have changed. Ignore it for now.

	// the provided podUIDs.
	RemoveOrphanedStatuses(podUIDs map[types.UID]bool)

	// GetContainerResourceAllocation returns checkpointed AllocatedResources value for the container
	GetContainerResourceAllocation(podUID string, containerName string) (v1.ResourceList, bool)

	// GetPodResizeStatus returns checkpointed PodStatus.Resize value

			return true
		}
	}
	return false
}

func ClaimContainsAllocatedResources(pvc *core.PersistentVolumeClaim) bool {
	if pvc == nil {
		return false
	}

	if pvc.Status.AllocatedResources != nil {
		return true
	}
	return false
}

func ClaimContainsAllocatedResourceStatus(pvc *core.PersistentVolumeClaim) bool {
	if pvc == nil {
		return false
	}

		return 0
	}
	cpuQuantity := container.Resources.Requests[v1.ResourceCPU]
	// In-place pod resize feature makes Container.Resources field mutable for CPU & memory.
	// AllocatedResources holds the value of Container.Resources.Requests when the pod was admitted.
	// We should return this value because this is what kubelet agreed to allocate for the container
	// and the value configured with runtime.