Use b.Fatal instead of klog.Fatal in scheduler perf tests

The test tool doesn't work properly with klog.Fatal

Signed-off-by: Aldo Culquicondor <acondor@google.com>
This commit is contained in:
Aldo Culquicondor 2020-03-23 14:53:15 -04:00
parent e74ad38854
commit 0e66e56e70

View File

@ -111,7 +111,10 @@ type testDataCollector interface {
func BenchmarkPerfScheduling(b *testing.B) { func BenchmarkPerfScheduling(b *testing.B) {
dataItems := DataItems{Version: "v1"} dataItems := DataItems{Version: "v1"}
tests := getSimpleTestCases(configFile) tests, err := parseTestCases(configFile)
if err != nil {
b.Fatal(err)
}
for _, test := range tests { for _, test := range tests {
name := fmt.Sprintf("%v/%vNodes/%vInitPods/%vPodsToSchedule", test.Desc, test.Nodes.Num, test.InitPods.Num, test.PodsToSchedule.Num) name := fmt.Sprintf("%v/%vNodes/%vInitPods/%vPodsToSchedule", test.Desc, test.Nodes.Num, test.InitPods.Num, test.PodsToSchedule.Num)
@ -131,14 +134,21 @@ func perfScheduling(test testCase, b *testing.B) []DataItem {
finalFunc, podInformer, clientset := mustSetupScheduler() finalFunc, podInformer, clientset := mustSetupScheduler()
defer finalFunc() defer finalFunc()
nodePreparer := getNodePreparer(test.Nodes, clientset) nodePreparer, err := getNodePreparer(test.Nodes, clientset)
if err != nil {
b.Fatal(err)
}
if err := nodePreparer.PrepareNodes(); err != nil { if err := nodePreparer.PrepareNodes(); err != nil {
klog.Fatalf("%v", err) b.Fatal(err)
} }
defer nodePreparer.CleanupNodes() defer nodePreparer.CleanupNodes()
createPods(setupNamespace, test.InitPods, clientset) if err := createPods(setupNamespace, test.InitPods, clientset); err != nil {
waitNumPodsScheduled(test.InitPods.Num, podInformer) b.Fatal(err)
}
if err := waitNumPodsScheduled(b, test.InitPods.Num, podInformer); err != nil {
b.Fatal(err)
}
// start benchmark // start benchmark
b.ResetTimer() b.ResetTimer()
@ -151,8 +161,12 @@ func perfScheduling(test testCase, b *testing.B) []DataItem {
} }
// Schedule the main workload // Schedule the main workload
createPods(testNamespace, test.PodsToSchedule, clientset) if err := createPods(testNamespace, test.PodsToSchedule, clientset); err != nil {
waitNumPodsScheduled(test.InitPods.Num+test.PodsToSchedule.Num, podInformer) b.Fatal(err)
}
if err := waitNumPodsScheduled(b, test.InitPods.Num+test.PodsToSchedule.Num, podInformer); err != nil {
b.Fatal(err)
}
close(stopCh) close(stopCh)
// Note: without this line we're taking the overhead of defer() into account. // Note: without this line we're taking the overhead of defer() into account.
@ -165,18 +179,19 @@ func perfScheduling(test testCase, b *testing.B) []DataItem {
return dataItems return dataItems
} }
func waitNumPodsScheduled(num int, podInformer coreinformers.PodInformer) { func waitNumPodsScheduled(b *testing.B, num int, podInformer coreinformers.PodInformer) error {
for { for {
scheduled, err := getScheduledPods(podInformer) scheduled, err := getScheduledPods(podInformer)
if err != nil { if err != nil {
klog.Fatalf("%v", err) return err
} }
if len(scheduled) >= num { if len(scheduled) >= num {
break break
} }
klog.Infof("got %d existing pods, required: %d", len(scheduled), num) klog.Infof("%s: got %d existing pods, required: %d", b.Name(), len(scheduled), num)
time.Sleep(1 * time.Second) time.Sleep(1 * time.Second)
} }
return nil
} }
func getTestDataCollectors(tc testCase, podInformer coreinformers.PodInformer, b *testing.B) []testDataCollector { func getTestDataCollectors(tc testCase, podInformer coreinformers.PodInformer, b *testing.B) []testDataCollector {
@ -189,7 +204,7 @@ func getTestDataCollectors(tc testCase, podInformer coreinformers.PodInformer, b
return collectors return collectors
} }
func getNodePreparer(nc nodeCase, clientset clientset.Interface) testutils.TestNodePreparer { func getNodePreparer(nc nodeCase, clientset clientset.Interface) (testutils.TestNodePreparer, error) {
var nodeStrategy testutils.PrepareNodeStrategy = &testutils.TrivialNodePrepareStrategy{} var nodeStrategy testutils.PrepareNodeStrategy = &testutils.TrivialNodePrepareStrategy{}
if nc.NodeAllocatableStrategy != nil { if nc.NodeAllocatableStrategy != nil {
nodeStrategy = nc.NodeAllocatableStrategy nodeStrategy = nc.NodeAllocatableStrategy
@ -200,44 +215,63 @@ func getNodePreparer(nc nodeCase, clientset clientset.Interface) testutils.TestN
} }
if nc.NodeTemplatePath != nil { if nc.NodeTemplatePath != nil {
node, err := getNodeSpecFromFile(nc.NodeTemplatePath)
if err != nil {
return nil, err
}
return framework.NewIntegrationTestNodePreparerWithNodeSpec( return framework.NewIntegrationTestNodePreparerWithNodeSpec(
clientset, clientset,
[]testutils.CountToStrategy{{Count: nc.Num, Strategy: nodeStrategy}}, []testutils.CountToStrategy{{Count: nc.Num, Strategy: nodeStrategy}},
getNodeSpecFromFile(nc.NodeTemplatePath), node,
) ), nil
} }
return framework.NewIntegrationTestNodePreparer( return framework.NewIntegrationTestNodePreparer(
clientset, clientset,
[]testutils.CountToStrategy{{Count: nc.Num, Strategy: nodeStrategy}}, []testutils.CountToStrategy{{Count: nc.Num, Strategy: nodeStrategy}},
"scheduler-perf-", "scheduler-perf-",
) ), nil
} }
func createPods(ns string, pc podCase, clientset clientset.Interface) { func createPods(ns string, pc podCase, clientset clientset.Interface) error {
strategy := getPodStrategy(pc) strategy, err := getPodStrategy(pc)
if err != nil {
return err
}
config := testutils.NewTestPodCreatorConfig() config := testutils.NewTestPodCreatorConfig()
config.AddStrategy(ns, pc.Num, strategy) config.AddStrategy(ns, pc.Num, strategy)
podCreator := testutils.NewTestPodCreator(clientset, config) podCreator := testutils.NewTestPodCreator(clientset, config)
podCreator.CreatePods() return podCreator.CreatePods()
} }
func getPodStrategy(pc podCase) testutils.TestPodCreateStrategy { func getPodStrategy(pc podCase) (testutils.TestPodCreateStrategy, error) {
basePod := makeBasePod() basePod := makeBasePod()
if pc.PodTemplatePath != nil { if pc.PodTemplatePath != nil {
basePod = getPodSpecFromFile(pc.PodTemplatePath) var err error
basePod, err = getPodSpecFromFile(pc.PodTemplatePath)
if err != nil {
return nil, err
}
} }
if pc.PersistentVolumeClaimTemplatePath == nil { if pc.PersistentVolumeClaimTemplatePath == nil {
return testutils.NewCustomCreatePodStrategy(basePod) return testutils.NewCustomCreatePodStrategy(basePod), nil
} }
pvTemplate := getPersistentVolumeSpecFromFile(pc.PersistentVolumeTemplatePath) pvTemplate, err := getPersistentVolumeSpecFromFile(pc.PersistentVolumeTemplatePath)
pvcTemplate := getPersistentVolumeClaimSpecFromFile(pc.PersistentVolumeClaimTemplatePath) if err != nil {
return testutils.NewCreatePodWithPersistentVolumeStrategy(pvcTemplate, getCustomVolumeFactory(pvTemplate), basePod) return nil, err
}
pvcTemplate, err := getPersistentVolumeClaimSpecFromFile(pc.PersistentVolumeClaimTemplatePath)
if err != nil {
return nil, err
}
return testutils.NewCreatePodWithPersistentVolumeStrategy(pvcTemplate, getCustomVolumeFactory(pvTemplate), basePod), nil
} }
func getSimpleTestCases(path string) []testCase { func parseTestCases(path string) ([]testCase, error) {
var simpleTests []simpleTestCases var simpleTests []simpleTestCases
getSpecFromFile(&path, &simpleTests) if err := getSpecFromFile(&path, &simpleTests); err != nil {
return nil, fmt.Errorf("parsing test cases: %v", err)
}
testCases := make([]testCase, 0) testCases := make([]testCase, 0)
for _, s := range simpleTests { for _, s := range simpleTests {
@ -250,41 +284,47 @@ func getSimpleTestCases(path string) []testCase {
} }
} }
return testCases return testCases, nil
} }
func getNodeSpecFromFile(path *string) *v1.Node { func getNodeSpecFromFile(path *string) (*v1.Node, error) {
nodeSpec := &v1.Node{} nodeSpec := &v1.Node{}
getSpecFromFile(path, nodeSpec) if err := getSpecFromFile(path, nodeSpec); err != nil {
return nodeSpec return nil, fmt.Errorf("parsing Node: %v", err)
}
return nodeSpec, nil
} }
func getPodSpecFromFile(path *string) *v1.Pod { func getPodSpecFromFile(path *string) (*v1.Pod, error) {
podSpec := &v1.Pod{} podSpec := &v1.Pod{}
getSpecFromFile(path, podSpec) if err := getSpecFromFile(path, podSpec); err != nil {
return podSpec return nil, fmt.Errorf("parsing Pod: %v", err)
}
return podSpec, nil
} }
func getPersistentVolumeSpecFromFile(path *string) *v1.PersistentVolume { func getPersistentVolumeSpecFromFile(path *string) (*v1.PersistentVolume, error) {
persistentVolumeSpec := &v1.PersistentVolume{} persistentVolumeSpec := &v1.PersistentVolume{}
getSpecFromFile(path, persistentVolumeSpec) if err := getSpecFromFile(path, persistentVolumeSpec); err != nil {
return persistentVolumeSpec return nil, fmt.Errorf("parsing PersistentVolume: %v", err)
}
return persistentVolumeSpec, nil
} }
func getPersistentVolumeClaimSpecFromFile(path *string) *v1.PersistentVolumeClaim { func getPersistentVolumeClaimSpecFromFile(path *string) (*v1.PersistentVolumeClaim, error) {
persistentVolumeClaimSpec := &v1.PersistentVolumeClaim{} persistentVolumeClaimSpec := &v1.PersistentVolumeClaim{}
getSpecFromFile(path, persistentVolumeClaimSpec) if err := getSpecFromFile(path, persistentVolumeClaimSpec); err != nil {
return persistentVolumeClaimSpec return nil, fmt.Errorf("parsing PersistentVolumeClaim: %v", err)
}
return persistentVolumeClaimSpec, nil
} }
func getSpecFromFile(path *string, spec interface{}) { func getSpecFromFile(path *string, spec interface{}) error {
bytes, err := ioutil.ReadFile(*path) bytes, err := ioutil.ReadFile(*path)
if err != nil { if err != nil {
klog.Fatalf("%v", err) return err
}
if err := yaml.Unmarshal(bytes, spec); err != nil {
klog.Fatalf("%v", err)
} }
return yaml.Unmarshal(bytes, spec)
} }
func getCustomVolumeFactory(pvTemplate *v1.PersistentVolume) func(id int) *v1.PersistentVolume { func getCustomVolumeFactory(pvTemplate *v1.PersistentVolume) func(id int) *v1.PersistentVolume {