Merge pull request #82 from AutuSnow/fix/issue-80-inner_loop_of_preparedDevices

The inner loop of preparedDevices does not filter driver

Author: k8s-ci-robot

pkg/driver/dra_hooks.go

@@ -347,6 +347,9 @@ func (cp *CPUDriver) prepareGroupedResourceClaim(ctx context.Context, claim *res
 	klog.Infof("prepareResourceClaim CDIDeviceName:%s envVar:%s qualifiedName:%v", deviceName, envVar, qualifiedName)
 	preparedDevices := []kubeletplugin.Device{}
 	for _, allocResult := range claim.Status.Allocation.Devices.Results {
+		if allocResult.Driver != cp.driverName {
+			continue
+		}
 		preparedDevice := kubeletplugin.Device{
 			PoolName:     allocResult.Pool,
 			DeviceName:   allocResult.Device,
@@ -402,6 +405,9 @@ func (cp *CPUDriver) prepareResourceClaim(_ context.Context, claim *resourceapi.
 	klog.Infof("prepareResourceClaim CDIDeviceName:%s envVar:%s qualifiedName:%v", deviceName, envVar, qualifiedName)
 	preparedDevices := []kubeletplugin.Device{}
 	for _, allocResult := range claim.Status.Allocation.Devices.Results {
+		if allocResult.Driver != cp.driverName {
+			continue
+		}
 		preparedDevice := kubeletplugin.Device{
 			PoolName:     allocResult.Pool,
 			DeviceName:   allocResult.Device,

pkg/driver/dra_hooks_test.go

@@ -540,6 +540,33 @@ func TestPrepareResourceClaims(t *testing.T) {
 			expectedResultsCount: 1,
 			expectedError:        true,
 		},
+		{
+			name:   "multi-driver claim - only our devices in preparedDevices",
+			driver: baseCPUDriver(),
+			claims: []*resourceapi.ResourceClaim{
+				{
+					ObjectMeta: metav1.ObjectMeta{UID: claimUID, Name: "my-claim"},
+					Status: resourceapi.ResourceClaimStatus{
+						Allocation: &resourceapi.AllocationResult{
+							Devices: resourceapi.DeviceAllocationResult{
+								Results: []resourceapi.DeviceRequestAllocationResult{
+									{Driver: testDriverName, Pool: testNodeName, Device: "cpudev0"},
+									{Driver: "other-driver", Pool: testNodeName, Device: "other-device"},
+								},
+							},
+						},
+					},
+				},
+			},
+			expectedResultsCount:    1,
+			expectedCdiDevicesCount: 1,
+			expectedCdiDevice:       cdiDeviceName,
+			expectedCdiEnvVar:       fmt.Sprintf("%s_%s=%s", cdiEnvVarPrefix, claimUID, "0"),
+			// only our driver's device should appear in preparedDevices
+			expectedPreparedDevices: []kubeletplugin.Device{
+				{PoolName: testNodeName, DeviceName: "cpudev0", CDIDeviceIDs: []string{cdiQualifiedName}},
+			},
+		},
 	}
 
 	for _, tc := range testCases {

test/e2e/cpu_assignment_test.go

@@ -31,6 +31,7 @@ import (
 	"github.com/onsi/gomega"
 	v1 "k8s.io/api/core/v1"
 	resourcev1 "k8s.io/api/resource/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/utils/cpuset"
 )
@@ -233,6 +234,65 @@ var _ = ginkgo.Describe("CPU Allocation", ginkgo.Serial, ginkgo.Ordered, ginkgo.
 				verifySharedPoolMatches(ctx, fxt, shrPod1, availableCPUs)
 				verifySharedPoolMatches(ctx, fxt, shrPod2, availableCPUs)
 			})
+
+			ginkgo.It("should allocate non-overlapping CPUs for multiple requests in the same grouped claim", func(ctx context.Context) {
+				if cpuDeviceMode != "grouped" {
+					ginkgo.Skip("this test only applies to grouped CPU device mode")
+				}
+				if availableCPUs.Size() < 2 {
+					ginkgo.Skip("need at least 2 available CPUs for this test")
+				}
+
+				fixture.By("creating a ResourceClaim with two requests each asking for 1 CPU")
+				cpuClaim := &resourcev1.ResourceClaim{
+					ObjectMeta: metav1.ObjectMeta{
+						Namespace:    fxt.Namespace.Name,
+						GenerateName: "claim-multi-request-",
+					},
+					Spec: resourcev1.ResourceClaimSpec{
+						Devices: resourcev1.DeviceClaim{
+							Requests: []resourcev1.DeviceRequest{
+								{
+									Name: "request-0",
+									Exactly: &resourcev1.ExactDeviceRequest{
+										DeviceClassName: "dra.cpu",
+										Capacity: &resourcev1.CapacityRequirements{
+											Requests: map[resourcev1.QualifiedName]resource.Quantity{
+												"dra.cpu/cpu": *resource.NewQuantity(1, resource.DecimalSI),
+											},
+										},
+									},
+								},
+								{
+									Name: "request-1",
+									Exactly: &resourcev1.ExactDeviceRequest{
+										DeviceClassName: "dra.cpu",
+										Capacity: &resourcev1.CapacityRequirements{
+											Requests: map[resourcev1.QualifiedName]resource.Quantity{
+												"dra.cpu/cpu": *resource.NewQuantity(1, resource.DecimalSI),
+											},
+										},
+									},
+								},
+							},
+						},
+					},
+				}
+				createdClaim, err := fxt.K8SClientset.ResourceV1().ResourceClaims(fxt.Namespace.Name).Create(ctx, cpuClaim, metav1.CreateOptions{})
+				gomega.Expect(err).ToNot(gomega.HaveOccurred())
+
+				fixture.By("creating a pod consuming the multi-request claim")
+				pod := makeTesterPodWithNamedClaim(fxt.Namespace.Name, dracpuTesterImage, createdClaim.Name, targetNode.Name)
+				createdPod, err := e2epod.CreateSync(ctx, fxt.K8SClientset, pod)
+				gomega.Expect(err).ToNot(gomega.HaveOccurred())
+
+				fixture.By("verifying the pod got 2 distinct CPUs with no overlap")
+				alloc := getTesterPodCPUAllocation(fxt.K8SClientset, ctx, createdPod)
+				fxt.Log.Info("multi-request claim allocation", "cpuAssigned", alloc.CPUAssigned.String())
+				gomega.Expect(alloc.CPUAssigned.Size()).To(gomega.Equal(2), "expected 2 distinct CPUs allocated")
+				gomega.Expect(alloc.CPUAssigned.IsSubsetOf(availableCPUs)).To(gomega.BeTrue(), "allocated CPUs must be within available set")
+
+			})
 		})
 	})
 })

test/e2e/e2e_suite_test.go

@@ -212,6 +212,50 @@ func parseCPUDeviceModeArg(arg string) (string, bool) {
 	return strings.TrimPrefix(arg, prefix), true
 }
 
+func makeTesterPodWithNamedClaim(ns, image, claimName string, nodeName string) *v1.Pod {
+	ginkgo.GinkgoHelper()
+	cpuQty := resource.NewQuantity(2, resource.DecimalSI)
+	memQty, err := resource.ParseQuantity("256Mi")
+	gomega.Expect(err).ToNot(gomega.HaveOccurred())
+
+	pod := &v1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			GenerateName: "tester-pod-named-claim-",
+			Namespace:    ns,
+		},
+		Spec: v1.PodSpec{
+			Containers: []v1.Container{
+				{
+					Name:    "tester-container-1",
+					Image:   image,
+					Command: []string{"/dracputester"},
+					Resources: v1.ResourceRequirements{
+						Requests: v1.ResourceList{
+							v1.ResourceCPU:    *cpuQty,
+							v1.ResourceMemory: memQty,
+						},
+						Limits: v1.ResourceList{
+							v1.ResourceCPU:    *cpuQty,
+							v1.ResourceMemory: memQty,
+						},
+						Claims: []v1.ResourceClaim{
+							{Name: "cpu-claim"},
+						},
+					},
+				},
+			},
+			ResourceClaims: []v1.PodResourceClaim{
+				{
+					Name:              "cpu-claim",
+					ResourceClaimName: ptr.To(claimName),
+				},
+			},
+			RestartPolicy: v1.RestartPolicyAlways,
+		},
+	}
+	return e2epod.PinToNode(pod, nodeName)
+}
+
 func makeResourceClaimSpec(cpus int, isConsumable bool) resourcev1.ResourceClaimSpec {
 	if !isConsumable {
 		return resourcev1.ResourceClaimSpec{