pRes.Containers = make([]*podresourcesv1.ContainerResources, 0, len(pod.Spec.InitContainers)+len(pod.Spec.Containers))

			for _, container := range pod.Spec.InitContainers {
				if !types.IsRestartableInitContainer(&container) {
					continue
				}

				pRes.Containers = append(pRes.Containers, p.getContainerResources(pod, &container))
			}
		}

		for _, container := range pod.Spec.Containers {

func IsNodeCriticalPod(pod *v1.Pod) bool {
	return IsCriticalPod(pod) && (pod.Spec.PriorityClassName == scheduling.SystemNodeCritical)
}

// IsRestartableInitContainer returns true if the initContainer has
// ContainerRestartPolicyAlways.
func IsRestartableInitContainer(initContainer *v1.Container) bool {
	if initContainer.RestartPolicy == nil {
		return false
	}

			Reason: UnknownContainerStatuses,
		}
	}
	unknownContainers := []string{}
	unreadyContainers := []string{}

	for _, container := range spec.InitContainers {
		if !kubetypes.IsRestartableInitContainer(&container) {
			continue
		}

		if containerStatus, ok := podutil.GetContainerStatus(containerStatuses, container.Name); ok {
			if !containerStatus.Ready {

		return "UNKNOWN"
	}
}

func getRestartableInitContainers(pod *v1.Pod) []v1.Container {
	var restartableInitContainers []v1.Container
	for _, c := range pod.Spec.InitContainers {
		if kubetypes.IsRestartableInitContainer(&c) {
			restartableInitContainers = append(restartableInitContainers, c)
		}
	}
	return restartableInitContainers
}

func (m *manager) AddPod(pod *v1.Pod) {
	m.workerLock.Lock()

		// get the init containers in reverse order
		ic := pod.Spec.InitContainers[len(pod.Spec.InitContainers)-i-1]

		to.terminated[ic.Name] = make(chan struct{})

		if types.IsRestartableInitContainer(&ic) {
			// sidecars need to wait for all main containers to exit
			to.prereqs[ic.Name] = append(to.prereqs[ic.Name], mainContainerChannels...)

			// Restart it if it is a restartable init container.
			if isPreviouslyInitialized && types.IsRestartableInitContainer(container) {
				changes.InitContainersToStart = append(changes.InitContainersToStart, i)
			}
			continue
		}

		if isPreviouslyInitialized && !types.IsRestartableInitContainer(container) {
			// after initialization, only restartable init containers need to be kept
			// running

			}

			// See https://github.com/kubernetes/enhancements/tree/master/keps/sig-node/753-sidecar-containers#resources-calculation-for-scheduling-and-pod-admission
			// for the detail.
			if types.IsRestartableInitContainer(&ctr) {
				reqRsrcsByRestartableInitCtrs[rsrcName] += qty
			} else if reqRsrcsByRestartableInitCtrs[rsrcName]+qty > reqRsrcsByInitCtrs[rsrcName] {

	// TODO: Remove this after the SidecarContainers feature gate graduates to GA.
	if !utilfeature.DefaultFeatureGate.Enabled(features.SidecarContainers) {
		for _, c := range admitPod.Spec.InitContainers {
			if types.IsRestartableInitContainer(&c) {
				message := fmt.Sprintf("Init container %q may not have a non-default restartPolicy", c.Name)
				klog.InfoS("Failed to admit pod", "pod", klog.KObj(admitPod), "message", message)
				return PodAdmitResult{

	// If so, add its cpuset to the cpuset of reusable CPUs for any new allocations.
	for _, initContainer := range pod.Spec.InitContainers {
		if container.Name == initContainer.Name {
			if types.IsRestartableInitContainer(&initContainer) {
				// If the container is a restartable init container, we should not
				// reuse its cpuset, as a restartable init container can run with
				// regular containers.
				break
			}

			break
		}

		// Since a restartable init container remains running for the full
		// duration of the pod's lifecycle, we should not remove it from the
		// memory manager state.
		if types.IsRestartableInitContainer(&initContainer) {
			continue
		}

		m.policyRemoveContainerByRef(string(pod.UID), initContainer.Name)
	}
}

// GetMemoryNUMANodes provides NUMA nodes that used to allocate the container memory