memory manager: add memory manager flag under kubelet options and kubelet config

The commit also includes generated files after `make generated_files`.

Signed-off-by: Byonggon Chun <bg.chun@samsung.com>

cmd/kubelet/app/options/options.go

@@ -550,4 +550,9 @@ Runtime log sanitization may introduce significant computation overhead and ther
 
 	// Graduated experimental flags, kept for backward compatibility
 	fs.BoolVar(&c.KernelMemcgNotification, "experimental-kernel-memcg-notification", c.KernelMemcgNotification, "Use kernelMemcgNotification configuration, this flag will be removed in 1.23.")
+
+	// Memory Manager Flags
+	fs.StringVar(&c.MemoryManagerPolicy, "memory-manager-policy", c.MemoryManagerPolicy, "Memory Manager policy to use. Possible values: 'none', 'static'. Default: 'none'")
+	// TODO: once documentation link is available, replace KEP link with the documentation one.
+	fs.Var(cliflag.NewBracketSeparatedSliceMapStringString(&c.ReservedMemory), "reserved-memory", "A comma separated list of bracket-enclosed configuration for memory manager (e.g. {numa-node=0, type=memory, limit=1Gi}, {numa-node=1, type=memory, limit=1Gi}). The total sum for each memory type should be equal to the sum of kube-reserved, system-reserved and eviction-threshold. See more details under https://github.com/kubernetes/enhancements/tree/master/keps/sig-node/1769-memory-manager#reserved-memory-flag")
 }

cmd/kubelet/app/server.go

@@ -71,6 +71,7 @@ import (
 	"k8s.io/kubernetes/cmd/kubelet/app/options"
 	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	api "k8s.io/kubernetes/pkg/apis/core"
+	corev1helper "k8s.io/kubernetes/pkg/apis/core/v1/helper"
 	"k8s.io/kubernetes/pkg/capabilities"
 	"k8s.io/kubernetes/pkg/credentialprovider"
 	"k8s.io/kubernetes/pkg/features"
@@ -687,6 +688,12 @@ func run(ctx context.Context, s *options.KubeletServer, kubeDeps *kubelet.Depend
 			s.SystemReserved["cpu"] = strconv.Itoa(reservedSystemCPUs.Size())
 			klog.Infof("After cpu setting is overwritten, KubeReserved=\"%v\", SystemReserved=\"%v\"", s.KubeReserved, s.SystemReserved)
 		}
+
+		reservedMemory, err := parseReservedMemoryConfig(s.ReservedMemory)
+		if err != nil {
+			return err
+		}
+
 		kubeReserved, err := parseResourceList(s.KubeReserved)
 		if err != nil {
 			return err
@@ -732,14 +739,16 @@ func run(ctx context.Context, s *options.KubeletServer, kubeDeps *kubelet.Depend
 					ReservedSystemCPUs:       reservedSystemCPUs,
 					HardEvictionThresholds:   hardEvictionThresholds,
 				},
-				QOSReserved:                           *experimentalQOSReserved,
-				ExperimentalCPUManagerPolicy:          s.CPUManagerPolicy,
-				ExperimentalCPUManagerReconcilePeriod: s.CPUManagerReconcilePeriod.Duration,
-				ExperimentalPodPidsLimit:              s.PodPidsLimit,
-				EnforceCPULimits:                      s.CPUCFSQuota,
-				CPUCFSQuotaPeriod:                     s.CPUCFSQuotaPeriod.Duration,
-				ExperimentalTopologyManagerPolicy:     s.TopologyManagerPolicy,
-				ExperimentalTopologyManagerScope:      s.TopologyManagerScope,
+				QOSReserved:                             *experimentalQOSReserved,
+				ExperimentalCPUManagerPolicy:            s.CPUManagerPolicy,
+				ExperimentalCPUManagerReconcilePeriod:   s.CPUManagerReconcilePeriod.Duration,
+				ExperimentalMemoryManagerPolicy:         s.MemoryManagerPolicy,
+				ExperimentalMemoryManagerReservedMemory: reservedMemory,
+				ExperimentalPodPidsLimit:                s.PodPidsLimit,
+				EnforceCPULimits:                        s.CPUCFSQuota,
+				CPUCFSQuotaPeriod:                       s.CPUCFSQuotaPeriod.Duration,
+				ExperimentalTopologyManagerPolicy:       s.TopologyManagerPolicy,
+				ExperimentalTopologyManagerScope:        s.TopologyManagerScope,
 			},
 			s.FailSwapOn,
 			devicePluginEnabled,
@@ -1296,6 +1305,59 @@ func parseResourceList(m map[string]string) (v1.ResourceList, error) {
 	return rl, nil
 }
 
+func parseReservedMemoryConfig(config []map[string]string) (map[int]map[v1.ResourceName]resource.Quantity, error) {
+	if len(config) == 0 {
+		return nil, nil
+	}
+
+	const (
+		indexKey = "numa-node"
+		typeKey  = "type"
+		limitKey = "limit"
+	)
+
+	keys := []string{indexKey, typeKey, limitKey}
+
+	// check whether all keys are present
+	for _, m := range config {
+		for _, key := range keys {
+			if _, exist := m[key]; !exist {
+				return nil, fmt.Errorf("key: %s is missing in given ReservedMemory flag: %v", key, config)
+			}
+		}
+	}
+
+	parsed := make(map[int]map[v1.ResourceName]resource.Quantity, len(config))
+	for _, m := range config {
+		idxInString, _ := m[indexKey]
+		idx, err := strconv.Atoi(idxInString)
+		if err != nil || idx < 0 {
+			return nil, fmt.Errorf("NUMA index conversion error for value: \"%s\"", idxInString)
+		}
+
+		typeInString, _ := m[typeKey]
+		v1Type := v1.ResourceName(typeInString)
+		if v1Type != v1.ResourceMemory && !corev1helper.IsHugePageResourceName(v1Type) {
+			return nil, fmt.Errorf("memory type conversion error, unknown type: \"%s\"", typeInString)
+		}
+		if corev1helper.IsHugePageResourceName(v1Type) {
+			if _, err := corev1helper.HugePageSizeFromResourceName(v1Type); err != nil {
+				return nil, fmt.Errorf("memory type conversion error, unknown type: \"%s\"", typeInString)
+			}
+		}
+
+		limitInString, _ := m[limitKey]
+		limit, err := resource.ParseQuantity(limitInString)
+		if err != nil || limit.Sign() != 1 {
+			return nil, fmt.Errorf("memory limit conversion error for value \"%s\"", limitInString)
+		}
+		parsed[idx] = make(map[v1.ResourceName]resource.Quantity)
+		parsed[idx][v1Type] = limit
+	}
+
+	return parsed, nil
+}
+
 // BootstrapKubeletConfigController constructs and bootstrap a configuration controller
 func BootstrapKubeletConfigController(dynamicConfigDir string, transform dynamickubeletconfig.TransformFunc) (*kubeletconfiginternal.KubeletConfiguration, *dynamickubeletconfig.Controller, error) {
 	if !utilfeature.DefaultFeatureGate.Enabled(features.DynamicKubeletConfig) {