github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-23 11:50:44 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #111371 from sivchari/improve-naming

Browse Source 
feat: improve naming
This commit is contained in:
Kubernetes Prow Robot 2022-12-14 02:23:37 -08:00 committed by GitHub
commit 68f808e6db
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 78 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
pkg/kubelet/cm/cgroup_manager_linux.go
View File

@ -306,8 +306,8 @@ func (m *cgroupManagerImpl) Destroy(cgroupConfig *CgroupConfig) error {
return nil return nil
} }
// getCpuWeight converts from the range [2, 262144] to [1, 10000] // getCPUWeight converts from the range [2, 262144] to [1, 10000]
func getCpuWeight(cpuShares *uint64) uint64 { func getCPUWeight(cpuShares *uint64) uint64 {
if cpuShares == nil { if cpuShares == nil {
return 0 return 0
} }
@ -359,18 +359,18 @@ func (m *cgroupManagerImpl) toResources(resourceConfig *ResourceConfig) *libcont
if resourceConfig.Memory != nil { if resourceConfig.Memory != nil {
resources.Memory = *resourceConfig.Memory resources.Memory = *resourceConfig.Memory
} }
if resourceConfig.CpuShares != nil { if resourceConfig.CPUShares != nil {
if libcontainercgroups.IsCgroup2UnifiedMode() { if libcontainercgroups.IsCgroup2UnifiedMode() {
resources.CpuWeight = getCpuWeight(resourceConfig.CpuShares) resources.CpuWeight = getCPUWeight(resourceConfig.CPUShares)
} else { } else {
resources.CpuShares = *resourceConfig.CpuShares resources.CpuShares = *resourceConfig.CPUShares
} }
} }
if resourceConfig.CpuQuota != nil { if resourceConfig.CPUQuota != nil {
resources.CpuQuota = *resourceConfig.CpuQuota resources.CpuQuota = *resourceConfig.CPUQuota
} }
if resourceConfig.CpuPeriod != nil { if resourceConfig.CPUPeriod != nil {
resources.CpuPeriod = *resourceConfig.CpuPeriod resources.CpuPeriod = *resourceConfig.CPUPeriod
} }
if resourceConfig.PidsLimit != nil { if resourceConfig.PidsLimit != nil {
resources.PidsLimit = *resourceConfig.PidsLimit resources.PidsLimit = *resourceConfig.PidsLimit
@ -530,7 +530,7 @@ func (m *cgroupManagerImpl) ReduceCPULimits(cgroupName CgroupName) error {
// Set lowest possible CpuShares value for the cgroup // Set lowest possible CpuShares value for the cgroup
minimumCPUShares := uint64(MinShares) minimumCPUShares := uint64(MinShares)
resources := &ResourceConfig{ resources := &ResourceConfig{
CpuShares: &minimumCPUShares, CPUShares: &minimumCPUShares,
} }
containerConfig := &CgroupConfig{ containerConfig := &CgroupConfig{
Name: cgroupName, Name: cgroupName,

8
pkg/kubelet/cm/container_manager_linux_test.go
View File

@ -127,16 +127,16 @@ func TestCgroupMountValidationMultipleSubsystem(t *testing.T) {
} }
func TestGetCpuWeight(t *testing.T) { func TestGetCpuWeight(t *testing.T) {
assert.Equal(t, uint64(0), getCpuWeight(nil)) assert.Equal(t, uint64(0), getCPUWeight(nil))
v := uint64(2) v := uint64(2)
assert.Equal(t, uint64(1), getCpuWeight(&v)) assert.Equal(t, uint64(1), getCPUWeight(&v))
v = uint64(262144) v = uint64(262144)
assert.Equal(t, uint64(10000), getCpuWeight(&v)) assert.Equal(t, uint64(10000), getCPUWeight(&v))
v = uint64(1000000000) v = uint64(1000000000)
assert.Equal(t, uint64(10000), getCpuWeight(&v)) assert.Equal(t, uint64(10000), getCPUWeight(&v))
} }
func TestSoftRequirementsValidationSuccess(t *testing.T) { func TestSoftRequirementsValidationSuccess(t *testing.T) {

14
pkg/kubelet/cm/helpers_linux.go
View File

@ -186,22 +186,22 @@ func ResourceConfigForPod(pod *v1.Pod, enforceCPULimits bool, cpuPeriod uint64,
// build the result // build the result
result := &ResourceConfig{} result := &ResourceConfig{}
if qosClass == v1.PodQOSGuaranteed { if qosClass == v1.PodQOSGuaranteed {
result.CpuShares = &cpuShares result.CPUShares = &cpuShares
result.CpuQuota = &cpuQuota result.CPUQuota = &cpuQuota
result.CpuPeriod = &cpuPeriod result.CPUPeriod = &cpuPeriod
result.Memory = &memoryLimits result.Memory = &memoryLimits
} else if qosClass == v1.PodQOSBurstable { } else if qosClass == v1.PodQOSBurstable {
result.CpuShares = &cpuShares result.CPUShares = &cpuShares
if cpuLimitsDeclared { if cpuLimitsDeclared {
result.CpuQuota = &cpuQuota result.CPUQuota = &cpuQuota
result.CpuPeriod = &cpuPeriod result.CPUPeriod = &cpuPeriod
} }
if memoryLimitsDeclared { if memoryLimitsDeclared {
result.Memory = &memoryLimits result.Memory = &memoryLimits
} }
} else { } else {
shares := uint64(MinShares) shares := uint64(MinShares)
result.CpuShares = &shares result.CPUShares = &shares
} }
result.HugePageLimit = hugePageLimits result.HugePageLimit = hugePageLimits

94
pkg/kubelet/cm/helpers_linux_test.go
View File

@ -25,7 +25,7 @@ import (
"testing" "testing"
"time" "time"
"k8s.io/api/core/v1" v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/api/resource" "k8s.io/apimachinery/pkg/api/resource"
utilfeature "k8s.io/apiserver/pkg/util/feature" utilfeature "k8s.io/apiserver/pkg/util/feature"
featuregatetesting "k8s.io/component-base/featuregate/testing" featuregatetesting "k8s.io/component-base/featuregate/testing"
@ -87,7 +87,7 @@ func TestResourceConfigForPod(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &minShares}, expected: &ResourceConfig{CPUShares: &minShares},
}, },
"burstable-no-limits": { "burstable-no-limits": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -101,7 +101,7 @@ func TestResourceConfigForPod(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstableShares}, expected: &ResourceConfig{CPUShares: &burstableShares},
}, },
"burstable-with-limits": { "burstable-with-limits": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -115,7 +115,7 @@ func TestResourceConfigForPod(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstableShares, CpuQuota: &burstableQuota, CpuPeriod: &defaultQuotaPeriod, Memory: &burstableMemory}, expected: &ResourceConfig{CPUShares: &burstableShares, CPUQuota: &burstableQuota, CPUPeriod: &defaultQuotaPeriod, Memory: &burstableMemory},
}, },
"burstable-with-limits-no-cpu-enforcement": { "burstable-with-limits-no-cpu-enforcement": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -129,7 +129,7 @@ func TestResourceConfigForPod(t *testing.T) {
}, },
enforceCPULimits: false, enforceCPULimits: false,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstableShares, CpuQuota: &cpuNoLimit, CpuPeriod: &defaultQuotaPeriod, Memory: &burstableMemory}, expected: &ResourceConfig{CPUShares: &burstableShares, CPUQuota: &cpuNoLimit, CPUPeriod: &defaultQuotaPeriod, Memory: &burstableMemory},
}, },
"burstable-partial-limits": { "burstable-partial-limits": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -146,7 +146,7 @@ func TestResourceConfigForPod(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstablePartialShares}, expected: &ResourceConfig{CPUShares: &burstablePartialShares},
}, },
"burstable-with-limits-with-tuned-quota": { "burstable-with-limits-with-tuned-quota": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -160,7 +160,7 @@ func TestResourceConfigForPod(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: tunedQuotaPeriod, quotaPeriod: tunedQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstableShares, CpuQuota: &burstableQuota, CpuPeriod: &tunedQuotaPeriod, Memory: &burstableMemory}, expected: &ResourceConfig{CPUShares: &burstableShares, CPUQuota: &burstableQuota, CPUPeriod: &tunedQuotaPeriod, Memory: &burstableMemory},
}, },
"burstable-with-limits-no-cpu-enforcement-with-tuned-quota": { "burstable-with-limits-no-cpu-enforcement-with-tuned-quota": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -174,7 +174,7 @@ func TestResourceConfigForPod(t *testing.T) {
}, },
enforceCPULimits: false, enforceCPULimits: false,
quotaPeriod: tunedQuotaPeriod, quotaPeriod: tunedQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstableShares, CpuQuota: &cpuNoLimit, CpuPeriod: &tunedQuotaPeriod, Memory: &burstableMemory}, expected: &ResourceConfig{CPUShares: &burstableShares, CPUQuota: &cpuNoLimit, CPUPeriod: &tunedQuotaPeriod, Memory: &burstableMemory},
}, },
"burstable-partial-limits-with-tuned-quota": { "burstable-partial-limits-with-tuned-quota": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -191,7 +191,7 @@ func TestResourceConfigForPod(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: tunedQuotaPeriod, quotaPeriod: tunedQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstablePartialShares}, expected: &ResourceConfig{CPUShares: &burstablePartialShares},
}, },
"guaranteed": { "guaranteed": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -205,7 +205,7 @@ func TestResourceConfigForPod(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &guaranteedShares, CpuQuota: &guaranteedQuota, CpuPeriod: &defaultQuotaPeriod, Memory: &guaranteedMemory}, expected: &ResourceConfig{CPUShares: &guaranteedShares, CPUQuota: &guaranteedQuota, CPUPeriod: &defaultQuotaPeriod, Memory: &guaranteedMemory},
}, },
"guaranteed-no-cpu-enforcement": { "guaranteed-no-cpu-enforcement": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -219,7 +219,7 @@ func TestResourceConfigForPod(t *testing.T) {
}, },
enforceCPULimits: false, enforceCPULimits: false,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &guaranteedShares, CpuQuota: &cpuNoLimit, CpuPeriod: &defaultQuotaPeriod, Memory: &guaranteedMemory}, expected: &ResourceConfig{CPUShares: &guaranteedShares, CPUQuota: &cpuNoLimit, CPUPeriod: &defaultQuotaPeriod, Memory: &guaranteedMemory},
}, },
"guaranteed-with-tuned-quota": { "guaranteed-with-tuned-quota": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -233,7 +233,7 @@ func TestResourceConfigForPod(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: tunedQuotaPeriod, quotaPeriod: tunedQuotaPeriod,
expected: &ResourceConfig{CpuShares: &guaranteedShares, CpuQuota: &guaranteedTunedQuota, CpuPeriod: &tunedQuotaPeriod, Memory: &guaranteedMemory}, expected: &ResourceConfig{CPUShares: &guaranteedShares, CPUQuota: &guaranteedTunedQuota, CPUPeriod: &tunedQuotaPeriod, Memory: &guaranteedMemory},
}, },
"guaranteed-no-cpu-enforcement-with-tuned-quota": { "guaranteed-no-cpu-enforcement-with-tuned-quota": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -247,7 +247,7 @@ func TestResourceConfigForPod(t *testing.T) {
}, },
enforceCPULimits: false, enforceCPULimits: false,
quotaPeriod: tunedQuotaPeriod, quotaPeriod: tunedQuotaPeriod,
expected: &ResourceConfig{CpuShares: &guaranteedShares, CpuQuota: &cpuNoLimit, CpuPeriod: &tunedQuotaPeriod, Memory: &guaranteedMemory}, expected: &ResourceConfig{CPUShares: &guaranteedShares, CPUQuota: &cpuNoLimit, CPUPeriod: &tunedQuotaPeriod, Memory: &guaranteedMemory},
}, },
"burstable-partial-limits-with-init-containers": { "burstable-partial-limits-with-init-containers": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -272,7 +272,7 @@ func TestResourceConfigForPod(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: tunedQuotaPeriod, quotaPeriod: tunedQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstablePartialShares}, expected: &ResourceConfig{CPUShares: &burstablePartialShares},
}, },
} }
@ -280,14 +280,14 @@ func TestResourceConfigForPod(t *testing.T) {
actual := ResourceConfigForPod(testCase.pod, testCase.enforceCPULimits, testCase.quotaPeriod, false) actual := ResourceConfigForPod(testCase.pod, testCase.enforceCPULimits, testCase.quotaPeriod, false)
if !reflect.DeepEqual(actual.CpuPeriod, testCase.expected.CpuPeriod) { if !reflect.DeepEqual(actual.CPUPeriod, testCase.expected.CPUPeriod) {
t.Errorf("unexpected result, test: %v, cpu period not as expected. Expected: %v, Actual:%v", testName, *testCase.expected.CpuPeriod, *actual.CpuPeriod) t.Errorf("unexpected result, test: %v, cpu period not as expected. Expected: %v, Actual:%v", testName, *testCase.expected.CPUPeriod, *actual.CPUPeriod)
} }
if !reflect.DeepEqual(actual.CpuQuota, testCase.expected.CpuQuota) { if !reflect.DeepEqual(actual.CPUQuota, testCase.expected.CPUQuota) {
t.Errorf("unexpected result, test: %v, cpu quota not as expected. Expected: %v, Actual:%v", testName, *testCase.expected.CpuQuota, *actual.CpuQuota) t.Errorf("unexpected result, test: %v, cpu quota not as expected. Expected: %v, Actual:%v", testName, *testCase.expected.CPUQuota, *actual.CPUQuota)
} }
if !reflect.DeepEqual(actual.CpuShares, testCase.expected.CpuShares) { if !reflect.DeepEqual(actual.CPUShares, testCase.expected.CPUShares) {
t.Errorf("unexpected result, test: %v, cpu shares not as expected. Expected: %v, Actual:%v", testName, *testCase.expected.CpuShares, &actual.CpuShares) t.Errorf("unexpected result, test: %v, cpu shares not as expected. Expected: %v, Actual:%v", testName, *testCase.expected.CPUShares, &actual.CPUShares)
} }
if !reflect.DeepEqual(actual.Memory, testCase.expected.Memory) { if !reflect.DeepEqual(actual.Memory, testCase.expected.Memory) {
t.Errorf("unexpected result, test: %v, memory not as expected. Expected: %v, Actual:%v", testName, *testCase.expected.Memory, *actual.Memory) t.Errorf("unexpected result, test: %v, memory not as expected. Expected: %v, Actual:%v", testName, *testCase.expected.Memory, *actual.Memory)
@ -332,7 +332,7 @@ func TestResourceConfigForPodWithCustomCPUCFSQuotaPeriod(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &minShares}, expected: &ResourceConfig{CPUShares: &minShares},
}, },
"burstable-no-limits": { "burstable-no-limits": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -346,7 +346,7 @@ func TestResourceConfigForPodWithCustomCPUCFSQuotaPeriod(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstableShares}, expected: &ResourceConfig{CPUShares: &burstableShares},
}, },
"burstable-with-limits": { "burstable-with-limits": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -360,7 +360,7 @@ func TestResourceConfigForPodWithCustomCPUCFSQuotaPeriod(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstableShares, CpuQuota: &burstableQuota, CpuPeriod: &defaultQuotaPeriod, Memory: &burstableMemory}, expected: &ResourceConfig{CPUShares: &burstableShares, CPUQuota: &burstableQuota, CPUPeriod: &defaultQuotaPeriod, Memory: &burstableMemory},
}, },
"burstable-with-limits-no-cpu-enforcement": { "burstable-with-limits-no-cpu-enforcement": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -374,7 +374,7 @@ func TestResourceConfigForPodWithCustomCPUCFSQuotaPeriod(t *testing.T) {
}, },
enforceCPULimits: false, enforceCPULimits: false,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstableShares, CpuQuota: &cpuNoLimit, CpuPeriod: &defaultQuotaPeriod, Memory: &burstableMemory}, expected: &ResourceConfig{CPUShares: &burstableShares, CPUQuota: &cpuNoLimit, CPUPeriod: &defaultQuotaPeriod, Memory: &burstableMemory},
}, },
"burstable-partial-limits": { "burstable-partial-limits": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -391,7 +391,7 @@ func TestResourceConfigForPodWithCustomCPUCFSQuotaPeriod(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstablePartialShares}, expected: &ResourceConfig{CPUShares: &burstablePartialShares},
}, },
"burstable-with-limits-with-tuned-quota": { "burstable-with-limits-with-tuned-quota": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -405,7 +405,7 @@ func TestResourceConfigForPodWithCustomCPUCFSQuotaPeriod(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: tunedQuotaPeriod, quotaPeriod: tunedQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstableShares, CpuQuota: &tunedQuota, CpuPeriod: &tunedQuotaPeriod, Memory: &burstableMemory}, expected: &ResourceConfig{CPUShares: &burstableShares, CPUQuota: &tunedQuota, CPUPeriod: &tunedQuotaPeriod, Memory: &burstableMemory},
}, },
"burstable-with-limits-no-cpu-enforcement-with-tuned-quota": { "burstable-with-limits-no-cpu-enforcement-with-tuned-quota": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -419,7 +419,7 @@ func TestResourceConfigForPodWithCustomCPUCFSQuotaPeriod(t *testing.T) {
}, },
enforceCPULimits: false, enforceCPULimits: false,
quotaPeriod: tunedQuotaPeriod, quotaPeriod: tunedQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstableShares, CpuQuota: &cpuNoLimit, CpuPeriod: &tunedQuotaPeriod, Memory: &burstableMemory}, expected: &ResourceConfig{CPUShares: &burstableShares, CPUQuota: &cpuNoLimit, CPUPeriod: &tunedQuotaPeriod, Memory: &burstableMemory},
}, },
"burstable-partial-limits-with-tuned-quota": { "burstable-partial-limits-with-tuned-quota": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -436,7 +436,7 @@ func TestResourceConfigForPodWithCustomCPUCFSQuotaPeriod(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: tunedQuotaPeriod, quotaPeriod: tunedQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstablePartialShares}, expected: &ResourceConfig{CPUShares: &burstablePartialShares},
}, },
"guaranteed": { "guaranteed": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -450,7 +450,7 @@ func TestResourceConfigForPodWithCustomCPUCFSQuotaPeriod(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &guaranteedShares, CpuQuota: &guaranteedQuota, CpuPeriod: &defaultQuotaPeriod, Memory: &guaranteedMemory}, expected: &ResourceConfig{CPUShares: &guaranteedShares, CPUQuota: &guaranteedQuota, CPUPeriod: &defaultQuotaPeriod, Memory: &guaranteedMemory},
}, },
"guaranteed-no-cpu-enforcement": { "guaranteed-no-cpu-enforcement": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -464,7 +464,7 @@ func TestResourceConfigForPodWithCustomCPUCFSQuotaPeriod(t *testing.T) {
}, },
enforceCPULimits: false, enforceCPULimits: false,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &guaranteedShares, CpuQuota: &cpuNoLimit, CpuPeriod: &defaultQuotaPeriod, Memory: &guaranteedMemory}, expected: &ResourceConfig{CPUShares: &guaranteedShares, CPUQuota: &cpuNoLimit, CPUPeriod: &defaultQuotaPeriod, Memory: &guaranteedMemory},
}, },
"guaranteed-with-tuned-quota": { "guaranteed-with-tuned-quota": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -478,7 +478,7 @@ func TestResourceConfigForPodWithCustomCPUCFSQuotaPeriod(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: tunedQuotaPeriod, quotaPeriod: tunedQuotaPeriod,
expected: &ResourceConfig{CpuShares: &guaranteedShares, CpuQuota: &guaranteedTunedQuota, CpuPeriod: &tunedQuotaPeriod, Memory: &guaranteedMemory}, expected: &ResourceConfig{CPUShares: &guaranteedShares, CPUQuota: &guaranteedTunedQuota, CPUPeriod: &tunedQuotaPeriod, Memory: &guaranteedMemory},
}, },
"guaranteed-no-cpu-enforcement-with-tuned-quota": { "guaranteed-no-cpu-enforcement-with-tuned-quota": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -492,7 +492,7 @@ func TestResourceConfigForPodWithCustomCPUCFSQuotaPeriod(t *testing.T) {
}, },
enforceCPULimits: false, enforceCPULimits: false,
quotaPeriod: tunedQuotaPeriod, quotaPeriod: tunedQuotaPeriod,
expected: &ResourceConfig{CpuShares: &guaranteedShares, CpuQuota: &cpuNoLimit, CpuPeriod: &tunedQuotaPeriod, Memory: &guaranteedMemory}, expected: &ResourceConfig{CPUShares: &guaranteedShares, CPUQuota: &cpuNoLimit, CPUPeriod: &tunedQuotaPeriod, Memory: &guaranteedMemory},
}, },
} }
@ -500,13 +500,13 @@ func TestResourceConfigForPodWithCustomCPUCFSQuotaPeriod(t *testing.T) {
actual := ResourceConfigForPod(testCase.pod, testCase.enforceCPULimits, testCase.quotaPeriod, false) actual := ResourceConfigForPod(testCase.pod, testCase.enforceCPULimits, testCase.quotaPeriod, false)
if !reflect.DeepEqual(actual.CpuPeriod, testCase.expected.CpuPeriod) { if !reflect.DeepEqual(actual.CPUPeriod, testCase.expected.CPUPeriod) {
t.Errorf("unexpected result, test: %v, cpu period not as expected", testName) t.Errorf("unexpected result, test: %v, cpu period not as expected", testName)
} }
if !reflect.DeepEqual(actual.CpuQuota, testCase.expected.CpuQuota) { if !reflect.DeepEqual(actual.CPUQuota, testCase.expected.CPUQuota) {
t.Errorf("unexpected result, test: %v, cpu quota not as expected", testName) t.Errorf("unexpected result, test: %v, cpu quota not as expected", testName)
} }
if !reflect.DeepEqual(actual.CpuShares, testCase.expected.CpuShares) { if !reflect.DeepEqual(actual.CPUShares, testCase.expected.CPUShares) {
t.Errorf("unexpected result, test: %v, cpu shares not as expected", testName) t.Errorf("unexpected result, test: %v, cpu shares not as expected", testName)
} }
if !reflect.DeepEqual(actual.Memory, testCase.expected.Memory) { if !reflect.DeepEqual(actual.Memory, testCase.expected.Memory) {
@ -683,7 +683,7 @@ func TestResourceConfigForPodWithEnforceMemoryQoS(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &minShares}, expected: &ResourceConfig{CPUShares: &minShares},
}, },
"burstable-no-limits": { "burstable-no-limits": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -697,7 +697,7 @@ func TestResourceConfigForPodWithEnforceMemoryQoS(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstableShares, Unified: map[string]string{"memory.min": "104857600"}}, expected: &ResourceConfig{CPUShares: &burstableShares, Unified: map[string]string{"memory.min": "104857600"}},
}, },
"burstable-with-limits": { "burstable-with-limits": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -711,7 +711,7 @@ func TestResourceConfigForPodWithEnforceMemoryQoS(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstableShares, CpuQuota: &burstableQuota, CpuPeriod: &defaultQuotaPeriod, Memory: &burstableMemory, Unified: map[string]string{"memory.min": "104857600"}}, expected: &ResourceConfig{CPUShares: &burstableShares, CPUQuota: &burstableQuota, CPUPeriod: &defaultQuotaPeriod, Memory: &burstableMemory, Unified: map[string]string{"memory.min": "104857600"}},
}, },
"burstable-with-limits-no-cpu-enforcement": { "burstable-with-limits-no-cpu-enforcement": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -725,7 +725,7 @@ func TestResourceConfigForPodWithEnforceMemoryQoS(t *testing.T) {
}, },
enforceCPULimits: false, enforceCPULimits: false,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstableShares, CpuQuota: &cpuNoLimit, CpuPeriod: &defaultQuotaPeriod, Memory: &burstableMemory, Unified: map[string]string{"memory.min": "104857600"}}, expected: &ResourceConfig{CPUShares: &burstableShares, CPUQuota: &cpuNoLimit, CPUPeriod: &defaultQuotaPeriod, Memory: &burstableMemory, Unified: map[string]string{"memory.min": "104857600"}},
}, },
"burstable-partial-limits": { "burstable-partial-limits": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -742,7 +742,7 @@ func TestResourceConfigForPodWithEnforceMemoryQoS(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstablePartialShares, Unified: map[string]string{"memory.min": "209715200"}}, expected: &ResourceConfig{CPUShares: &burstablePartialShares, Unified: map[string]string{"memory.min": "209715200"}},
}, },
"burstable-with-limits-with-tuned-quota": { "burstable-with-limits-with-tuned-quota": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -756,7 +756,7 @@ func TestResourceConfigForPodWithEnforceMemoryQoS(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: tunedQuotaPeriod, quotaPeriod: tunedQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstableShares, CpuQuota: &burstableQuota, CpuPeriod: &tunedQuotaPeriod, Memory: &burstableMemory, Unified: map[string]string{"memory.min": "104857600"}}, expected: &ResourceConfig{CPUShares: &burstableShares, CPUQuota: &burstableQuota, CPUPeriod: &tunedQuotaPeriod, Memory: &burstableMemory, Unified: map[string]string{"memory.min": "104857600"}},
}, },
"burstable-with-limits-no-cpu-enforcement-with-tuned-quota": { "burstable-with-limits-no-cpu-enforcement-with-tuned-quota": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -770,7 +770,7 @@ func TestResourceConfigForPodWithEnforceMemoryQoS(t *testing.T) {
}, },
enforceCPULimits: false, enforceCPULimits: false,
quotaPeriod: tunedQuotaPeriod, quotaPeriod: tunedQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstableShares, CpuQuota: &cpuNoLimit, CpuPeriod: &tunedQuotaPeriod, Memory: &burstableMemory, Unified: map[string]string{"memory.min": "104857600"}}, expected: &ResourceConfig{CPUShares: &burstableShares, CPUQuota: &cpuNoLimit, CPUPeriod: &tunedQuotaPeriod, Memory: &burstableMemory, Unified: map[string]string{"memory.min": "104857600"}},
}, },
"burstable-partial-limits-with-tuned-quota": { "burstable-partial-limits-with-tuned-quota": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -787,7 +787,7 @@ func TestResourceConfigForPodWithEnforceMemoryQoS(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: tunedQuotaPeriod, quotaPeriod: tunedQuotaPeriod,
expected: &ResourceConfig{CpuShares: &burstablePartialShares, Unified: map[string]string{"memory.min": "209715200"}}, expected: &ResourceConfig{CPUShares: &burstablePartialShares, Unified: map[string]string{"memory.min": "209715200"}},
}, },
"guaranteed": { "guaranteed": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -801,7 +801,7 @@ func TestResourceConfigForPodWithEnforceMemoryQoS(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &guaranteedShares, CpuQuota: &guaranteedQuota, CpuPeriod: &defaultQuotaPeriod, Memory: &guaranteedMemory, Unified: map[string]string{"memory.min": "104857600"}}, expected: &ResourceConfig{CPUShares: &guaranteedShares, CPUQuota: &guaranteedQuota, CPUPeriod: &defaultQuotaPeriod, Memory: &guaranteedMemory, Unified: map[string]string{"memory.min": "104857600"}},
}, },
"guaranteed-no-cpu-enforcement": { "guaranteed-no-cpu-enforcement": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -815,7 +815,7 @@ func TestResourceConfigForPodWithEnforceMemoryQoS(t *testing.T) {
}, },
enforceCPULimits: false, enforceCPULimits: false,
quotaPeriod: defaultQuotaPeriod, quotaPeriod: defaultQuotaPeriod,
expected: &ResourceConfig{CpuShares: &guaranteedShares, CpuQuota: &cpuNoLimit, CpuPeriod: &defaultQuotaPeriod, Memory: &guaranteedMemory, Unified: map[string]string{"memory.min": "104857600"}}, expected: &ResourceConfig{CPUShares: &guaranteedShares, CPUQuota: &cpuNoLimit, CPUPeriod: &defaultQuotaPeriod, Memory: &guaranteedMemory, Unified: map[string]string{"memory.min": "104857600"}},
}, },
"guaranteed-with-tuned-quota": { "guaranteed-with-tuned-quota": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -829,7 +829,7 @@ func TestResourceConfigForPodWithEnforceMemoryQoS(t *testing.T) {
}, },
enforceCPULimits: true, enforceCPULimits: true,
quotaPeriod: tunedQuotaPeriod, quotaPeriod: tunedQuotaPeriod,
expected: &ResourceConfig{CpuShares: &guaranteedShares, CpuQuota: &guaranteedTunedQuota, CpuPeriod: &tunedQuotaPeriod, Memory: &guaranteedMemory, Unified: map[string]string{"memory.min": "104857600"}}, expected: &ResourceConfig{CPUShares: &guaranteedShares, CPUQuota: &guaranteedTunedQuota, CPUPeriod: &tunedQuotaPeriod, Memory: &guaranteedMemory, Unified: map[string]string{"memory.min": "104857600"}},
}, },
"guaranteed-no-cpu-enforcement-with-tuned-quota": { "guaranteed-no-cpu-enforcement-with-tuned-quota": {
pod: &v1.Pod{ pod: &v1.Pod{
@ -843,7 +843,7 @@ func TestResourceConfigForPodWithEnforceMemoryQoS(t *testing.T) {
}, },
enforceCPULimits: false, enforceCPULimits: false,
quotaPeriod: tunedQuotaPeriod, quotaPeriod: tunedQuotaPeriod,
expected: &ResourceConfig{CpuShares: &guaranteedShares, CpuQuota: &cpuNoLimit, CpuPeriod: &tunedQuotaPeriod, Memory: &guaranteedMemory, Unified: map[string]string{"memory.min": "104857600"}}, expected: &ResourceConfig{CPUShares: &guaranteedShares, CPUQuota: &cpuNoLimit, CPUPeriod: &tunedQuotaPeriod, Memory: &guaranteedMemory, Unified: map[string]string{"memory.min": "104857600"}},
}, },
} }

4
pkg/kubelet/cm/node_container_manager_linux.go
View File

@ -155,7 +155,7 @@ func enforceExistingCgroup(cgroupManager CgroupManager, cName CgroupName, rl v1.
Name: cName, Name: cName,
ResourceParameters: rp, ResourceParameters: rp,
} }
klog.V(4).InfoS("Enforcing limits on cgroup", "cgroupName", cName, "cpuShares", cgroupConfig.ResourceParameters.CpuShares, "memory", cgroupConfig.ResourceParameters.Memory, "pidsLimit", cgroupConfig.ResourceParameters.PidsLimit) klog.V(4).InfoS("Enforcing limits on cgroup", "cgroupName", cName, "cpuShares", cgroupConfig.ResourceParameters.CPUShares, "memory", cgroupConfig.ResourceParameters.Memory, "pidsLimit", cgroupConfig.ResourceParameters.PidsLimit)
if err := cgroupManager.Validate(cgroupConfig.Name); err != nil { if err := cgroupManager.Validate(cgroupConfig.Name); err != nil {
return err return err
} }
@ -180,7 +180,7 @@ func getCgroupConfig(rl v1.ResourceList) *ResourceConfig {
if q, exists := rl[v1.ResourceCPU]; exists { if q, exists := rl[v1.ResourceCPU]; exists {
// CPU is defined in milli-cores. // CPU is defined in milli-cores.
val := MilliCPUToShares(q.MilliValue()) val := MilliCPUToShares(q.MilliValue())
rc.CpuShares = &val rc.CPUShares = &val
} }
if q, exists := rl[pidlimit.PIDs]; exists { if q, exists := rl[pidlimit.PIDs]; exists {
val := q.Value() val := q.Value()

6
pkg/kubelet/cm/qos_container_manager_linux.go
View File

@ -98,7 +98,7 @@ func (m *qosContainerManagerImpl) Start(getNodeAllocatable func() v1.ResourceLis
// the BestEffort QoS class has a statically configured minShares value // the BestEffort QoS class has a statically configured minShares value
if qosClass == v1.PodQOSBestEffort { if qosClass == v1.PodQOSBestEffort {
minShares := uint64(MinShares) minShares := uint64(MinShares)
resourceParameters.CpuShares = &minShares resourceParameters.CPUShares = &minShares
} }
// containerConfig object stores the cgroup specifications // containerConfig object stores the cgroup specifications
@ -184,11 +184,11 @@ func (m *qosContainerManagerImpl) setCPUCgroupConfig(configs map[v1.PodQOSClass]
// make sure best effort is always 2 shares // make sure best effort is always 2 shares
bestEffortCPUShares := uint64(MinShares) bestEffortCPUShares := uint64(MinShares)
configs[v1.PodQOSBestEffort].ResourceParameters.CpuShares = &bestEffortCPUShares configs[v1.PodQOSBestEffort].ResourceParameters.CPUShares = &bestEffortCPUShares
// set burstable shares based on current observe state // set burstable shares based on current observe state
burstableCPUShares := MilliCPUToShares(burstablePodCPURequest) burstableCPUShares := MilliCPUToShares(burstablePodCPURequest)
configs[v1.PodQOSBurstable].ResourceParameters.CpuShares = &burstableCPUShares configs[v1.PodQOSBurstable].ResourceParameters.CPUShares = &burstableCPUShares
return nil return nil
} }

6
pkg/kubelet/cm/types.go
View File

@ -26,11 +26,11 @@ type ResourceConfig struct {
// Memory limit (in bytes). // Memory limit (in bytes).
Memory *int64 Memory *int64
// CPU shares (relative weight vs. other containers). // CPU shares (relative weight vs. other containers).
CpuShares *uint64 CPUShares *uint64
// CPU hardcap limit (in usecs). Allowed cpu time in a given period. // CPU hardcap limit (in usecs). Allowed cpu time in a given period.
CpuQuota *int64 CPUQuota *int64
// CPU quota period. // CPU quota period.
CpuPeriod *uint64 CPUPeriod *uint64
// HugePageLimit map from page size (in bytes) to limit (in bytes) // HugePageLimit map from page size (in bytes) to limit (in bytes)
HugePageLimit map[int64]int64 HugePageLimit map[int64]int64
// Maximum number of pids // Maximum number of pids

4
pkg/kubelet/preemption/preemption_test.go
View File

@ -495,7 +495,7 @@ func parseCPUToInt64(res string) int64 {
return (&r).MilliValue() return (&r).MilliValue()
} }
func parseNonCpuResourceToInt64(res string) int64 { func parseNonCPUResourceToInt64(res string) int64 {
r := resource.MustParse(res) r := resource.MustParse(res)
return (&r).Value() return (&r).Value()
} }
@ -511,7 +511,7 @@ func getAdmissionRequirementList(cpu, memory, pods int) admissionRequirementList
if memory > 0 { if memory > 0 {
reqs = append(reqs, &admissionRequirement{ reqs = append(reqs, &admissionRequirement{
resourceName: v1.ResourceMemory, resourceName: v1.ResourceMemory,
quantity: parseNonCpuResourceToInt64(fmt.Sprintf("%dMi", memory)), quantity: parseNonCPUResourceToInt64(fmt.Sprintf("%dMi", memory)),
}) })
} }
if pods > 0 { if pods > 0 {