Internal change

test/kubernetes/benchmarks/BUILD

@@ -75,6 +75,7 @@ go_library(
         "//test/kubernetes/k8sctx",
         "//test/kubernetes/testcluster",
         "@io_k8s_api//core/v1:go_default_library",
+        "@io_k8s_apimachinery//pkg/api/resource:go_default_library",
         "@org_golang_x_time//rate:go_default_library",
     ],
 )

test/kubernetes/benchmarks/abslbuild.go

@@ -65,10 +65,15 @@ func BuildABSL(ctx context.Context, t *testing.T, k8sCtx k8sctx.KubernetesContex
 	if image, err = k8sCtx.ResolveImage(ctx, image); err != nil {
 		t.Fatalf("Failed to resolve image: %v", err)
 	}
+	supportsPV, err := cluster.SupportsPersistentVolumes(ctx)
+	if err != nil {
+		t.Fatalf("Failed to check if cluster supports persistent volumes: %v", err)
+	}
 
 	for _, test := range []struct {
-		name   string
-		volume *v13.Volume
+		name     string
+		volume   *v13.Volume
+		disabled bool
 	}{
 		{
 			name:   "RootFS",
@@ -93,9 +98,13 @@ func BuildABSL(ctx context.Context, t *testing.T, k8sCtx k8sctx.KubernetesContex
 					},
 				},
 			},
+			disabled: !supportsPV,
 		},
 	} {
 		t.Run(test.name, func(t *testing.T) {
+			if test.disabled {
+				t.Skip("Persistent volumes are not supported in this cluster")
+			}
 			endProfiling, err := profiling.MaybeSetup(ctx, t, k8sCtx, cluster, benchmarkNS)
 			if err != nil {
 				t.Fatalf("Failed to setup profiling: %v", err)

test/kubernetes/benchmarks/ffmpeg.go

@@ -69,10 +69,15 @@ func RunFFMPEG(ctx context.Context, t *testing.T, k8sCtx k8sctx.KubernetesContex
 	if image, err = k8sCtx.ResolveImage(ctx, image); err != nil {
 		t.Fatalf("Failed to resolve image: %v", err)
 	}
+	supportsPV, err := cluster.SupportsPersistentVolumes(ctx)
+	if err != nil {
+		t.Fatalf("Failed to check if cluster supports persistent volumes: %v", err)
+	}
 
 	for _, test := range []struct {
-		name   string
-		volume *v13.Volume
+		name     string
+		volume   *v13.Volume
+		disabled bool
 	}{
 		{
 			name:   "RootFS",
@@ -97,9 +102,13 @@ func RunFFMPEG(ctx context.Context, t *testing.T, k8sCtx k8sctx.KubernetesContex
 					},
 				},
 			},
+			disabled: !supportsPV,
 		},
 	} {
 		t.Run(test.name, func(t *testing.T) {
+			if test.disabled {
+				t.Skip("Persistent volumes are not supported in this cluster")
+			}
 			endProfiling, err := profiling.MaybeSetup(ctx, t, k8sCtx, cluster, benchmarkNS)
 			if err != nil {
 				t.Fatalf("Failed to setup profiling: %v", err)

test/kubernetes/benchmarks/grpc.go

@@ -70,10 +70,15 @@ func BuildGRPC(ctx context.Context, t *testing.T, k8sCtx k8sctx.KubernetesContex
 	if image, err = k8sCtx.ResolveImage(ctx, image); err != nil {
 		t.Fatalf("Failed to resolve image: %v", err)
 	}
+	supportsPV, err := cluster.SupportsPersistentVolumes(ctx)
+	if err != nil {
+		t.Fatalf("Failed to check if cluster supports persistent volumes: %v", err)
+	}
 
 	for _, test := range []struct {
-		name   string
-		volume *v13.Volume
+		name     string
+		volume   *v13.Volume
+		disabled bool
 	}{
 		{
 			name:   "RootFS",
@@ -98,9 +103,13 @@ func BuildGRPC(ctx context.Context, t *testing.T, k8sCtx k8sctx.KubernetesContex
 					},
 				},
 			},
+			disabled: !supportsPV,
 		},
 	} {
 		t.Run(test.name, func(t *testing.T) {
+			if test.disabled {
+				t.Skip("Persistent volumes are not supported in this cluster")
+			}
 			endProfiling, err := profiling.MaybeSetup(ctx, t, k8sCtx, cluster, benchmarkNS)
 			if err != nil {
 				t.Fatalf("Failed to setup profiling: %v", err)

test/kubernetes/benchmarks/gsutil.go

@@ -71,12 +71,17 @@ func RunGSUtil(ctx context.Context, t *testing.T, k8sCtx k8sctx.KubernetesContex
 	if image, err = k8sCtx.ResolveImage(ctx, image); err != nil {
 		t.Fatalf("Failed to resolve image: %v", err)
 	}
+	supportsPV, err := cluster.SupportsPersistentVolumes(ctx)
+	if err != nil {
+		t.Fatalf("Failed to check if cluster supports persistent volumes: %v", err)
+	}
 
 	// Run tests with different volume types. We could also use gsutil
 	// parallel sliced downloads as a test dimension.
 	for _, storage := range []struct {
-		name   string
-		volume *v13.Volume
+		name     string
+		volume   *v13.Volume
+		disabled bool
 	}{
 		{
 			name:   "RootFS",
@@ -101,9 +106,13 @@ func RunGSUtil(ctx context.Context, t *testing.T, k8sCtx k8sctx.KubernetesContex
 					},
 				},
 			},
+			disabled: !supportsPV,
 		},
 	} {
 		t.Run(storage.name, func(t *testing.T) {
+			if storage.disabled {
+				t.Skip("Persistent volumes are not supported in this cluster")
+			}
 			for _, slicing := range []struct {
 				name   string
 				option string

test/kubernetes/benchmarks/nginx.go

@@ -78,21 +78,12 @@ func BenchmarkNginx(ctx context.Context, t *testing.T, k8sCtx k8sctx.KubernetesC
 	if nginxImage, err = k8sCtx.ResolveImage(ctx, nginxImage); err != nil {
 		t.Fatalf("Failed to resolve image: %v", err)
 	}
-
-	persistentVol, err := cluster.CreatePersistentVolume(ctx, benchmarkNS.GetPersistentVolume("nginx-data", "30Gi"))
-	if err != nil {
-		t.Fatalf("Failed to create persistent volume: %v", err)
-	}
-	defer cluster.DeletePersistentVolume(ctx, persistentVol)
-
-	for _, test := range []struct {
-		// Name of the test.
-		name string
-		// Suffix for pod names, must be short enough.
+	type nginxTest struct {
+		name   string
 		suffix string
-		// Volume to mount at /tmp/root.
 		volume *v13.Volume
-	}{
+	}
+	tests := []nginxTest{
 		{
 			name:   "RootFS",
 			suffix: "rootfs",
@@ -108,7 +99,18 @@ func BenchmarkNginx(ctx context.Context, t *testing.T, k8sCtx k8sctx.KubernetesC
 				},
 			},
 		},
-		{
+	}
+	supportsPV, err := cluster.SupportsPersistentVolumes(ctx)
+	if err != nil {
+		t.Fatalf("Failed to check if cluster supports persistent volumes: %v", err)
+	}
+	if supportsPV {
+		persistentVol, err := cluster.CreatePersistentVolume(ctx, benchmarkNS.GetPersistentVolume("nginx-data", "30Gi"))
+		if err != nil {
+			t.Fatalf("Failed to create persistent volume: %v", err)
+		}
+		defer cluster.DeletePersistentVolume(ctx, persistentVol)
+		tests = append(tests, nginxTest{
 			name:   "PersistentVolume",
 			suffix: "pvol",
 			volume: &v13.Volume{
@@ -119,8 +121,10 @@ func BenchmarkNginx(ctx context.Context, t *testing.T, k8sCtx k8sctx.KubernetesC
 					},
 				},
 			},
-		},
-	} {
+		})
+	}
+
+	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			endProfiling, err := profiling.MaybeSetup(ctx, t, k8sCtx, cluster, benchmarkNS)
 			if err != nil {

test/kubernetes/benchmarks/rubydev.go

@@ -75,9 +75,15 @@ func RunRubyDev(ctx context.Context, t *testing.T, k8sCtx k8sctx.KubernetesConte
 	if image, err = k8sCtx.ResolveImage(ctx, image); err != nil {
 		t.Fatalf("failed to resolve image: %v", err)
 	}
+	supportsPV, err := cluster.SupportsPersistentVolumes(ctx)
+	if err != nil {
+		t.Fatalf("Failed to check if cluster supports persistent volumes: %v", err)
+	}
+
 	for _, test := range []struct {
-		name   string
-		volume *v13.Volume
+		name     string
+		volume   *v13.Volume
+		disabled bool
 	}{
 		{
 			name:   "RootFS",
@@ -102,9 +108,13 @@ func RunRubyDev(ctx context.Context, t *testing.T, k8sCtx k8sctx.KubernetesConte
 					},
 				},
 			},
+			disabled: !supportsPV,
 		},
 	} {
 		t.Run(test.name, func(t *testing.T) {
+			if test.disabled {
+				t.Skip("Persistent volumes are not supported in this cluster")
+			}
 			endProfiling, err := profiling.MaybeSetup(ctx, t, k8sCtx, cluster, benchmarkNS)
 			if err != nil {
 				t.Fatalf("Failed to setup profiling: %v", err)

test/kubernetes/benchmarks/startup.go

@@ -32,6 +32,7 @@ import (
 	"gvisor.dev/gvisor/test/kubernetes/k8sctx"
 	"gvisor.dev/gvisor/test/kubernetes/testcluster"
 	v13 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
 )
 
 const (
@@ -183,6 +184,12 @@ func runPodAndGetMetrics(ctx context.Context, t *testing.T, k8sCtx k8sctx.Kubern
 	if err != nil {
 		return nil, fmt.Errorf("failed to set pod for test nodepool: %w", err)
 	}
+	// If the pod has explicit limits set as a result of the runtime choice,
+	// clip them to a tiny size. This is because for runtimes that require
+	// explicit limits (e.g. Kata), initialization may scale together with
+	// the limits, which isn't the point of this benchmark; we want to measure
+	// the runtime of starting a container with minimal footprint.
+	maybeClipResources(p)
 	createdAt := time.Now()
 	p, err = cluster.CreatePod(ctx, p)
 	if err != nil {
@@ -404,3 +411,31 @@ func runPodAndGetMetrics(ctx context.Context, t *testing.T, k8sCtx k8sctx.Kubern
 	deleted = true
 	return metrics, nil
 }
+
+func maybeClipResources(p *v13.Pod) {
+	// Same size as e2-medium.
+	const (
+		cpuLimit    = "2"
+		memoryLimit = "4Gi"
+	)
+	for _, containers := range [][]v13.Container{
+		p.Spec.InitContainers,
+		p.Spec.Containers,
+	} {
+		for i := range containers {
+			for _, resources := range []v13.ResourceList{
+				containers[i].Resources.Limits,
+				containers[i].Resources.Requests,
+			} {
+				if resources != nil {
+					if _, ok := resources[v13.ResourceCPU]; ok {
+						resources[v13.ResourceCPU] = resource.MustParse(cpuLimit)
+					}
+					if _, ok := resources[v13.ResourceMemory]; ok {
+						resources[v13.ResourceMemory] = resource.MustParse(memoryLimit)
+					}
+				}
+			}
+		}
+	}
+}