feat: Partionable Devices Support

Author: MenD32

cluster-autoscaler/simulator/dynamicresources/utils/utilization.go

@@ -101,25 +101,31 @@ func calculatePoolUtil(unallocated, allocated []resourceapi.Device, resourceSlic
 	}
 
 	// we want to find the counter that is most utilized, since it is the "bottleneck" of the pool
-	var maxUtilization float64
-	if devicesWithoutCounters == 0 {
-		maxUtilization = 0
-	} else {
-		maxUtilization = float64(allocatedDevicesWithoutCounters) / float64(devicesWithoutCounters)
+	var partitionableUtilization float64 = 0
+	var atomicDevicesUtilization float64 = 0
+	if devicesWithoutCounters != 0 {
+		atomicDevicesUtilization = partitionableUtilization
+	}
+	if len(TotalConsumedCounters) == 0 {
+		return atomicDevicesUtilization
 	}
 	for counterSet, counters := range TotalConsumedCounters {
 		for counterName, totalValue := range counters {
+			if totalValue.IsZero() {
+				continue
+			}
 			if allocatedSet, exists := allocatedConsumedCounters[counterSet]; exists {
-				if allocatedValue, exists := allocatedSet[counterName]; exists && !totalValue.IsZero() {
+				if allocatedValue, exists := allocatedSet[counterName]; exists {
 					utilization := float64(allocatedValue.Value()) / float64(totalValue.Value())
-					if utilization > maxUtilization {
-						maxUtilization = utilization
+					if utilization > partitionableUtilization {
+						partitionableUtilization = utilization
 					}
 				}
 			}
 		}
 	}
-	return maxUtilization
+	// when a pool has both atomic and partitionable devices, we sum their utilizations since they are mutually exclusive
+	return partitionableUtilization + atomicDevicesUtilization
 }
 
 // calculateConsumedCounters calculates the total counters consumed by a list of devices

cluster-autoscaler/simulator/dynamicresources/utils/utilization_test.go

@@ -143,10 +143,10 @@ func TestDynamicResourceUtilization(t *testing.T) {
 			wantHighestUtilizationName: apiv1.ResourceName(fmt.Sprintf("%s/%s", fooDriver, "pool1")),
 		},
 		{
-			testName: "",
+			testName: "partitionable devices, 2/4 partitions used",
 			nodeInfo: framework.NewNodeInfo(node,
 				mergeLists(
-					testResourceSlicesWithPartionableDevices(fooDriver, "pool1", "node", 2, 4),
+					testResourceSlicesWithPartionableDevices(fooDriver, "pool1", "gpu-0", "node", 2, 4),
 				),
 				mergeLists(
 					testPodsWithCustomClaims(fooDriver, "pool1", "node", []string{"gpu-0-partition-0", "gpu-0-partition-1"}),
@@ -160,6 +160,25 @@ func TestDynamicResourceUtilization(t *testing.T) {
 			wantHighestUtilization:     0.5,
 			wantHighestUtilizationName: apiv1.ResourceName(fmt.Sprintf("%s/%s", fooDriver, "pool1")),
 		},
+		{
+			testName: "multi-GPU partitionable devices, 2/8 partitions used",
+			nodeInfo: framework.NewNodeInfo(node,
+				mergeLists(
+					testResourceSlicesWithPartionableDevices(fooDriver, "pool1", "gpu-0", "node", 2, 4),
+					testResourceSlicesWithPartionableDevices(fooDriver, "pool1", "gpu-1", "node", 0, 4),
+				),
+				mergeLists(
+					testPodsWithCustomClaims(fooDriver, "pool1", "node", []string{"gpu-0-partition-0", "gpu-0-partition-1"}),
+				)...,
+			),
+			wantUtilization: map[string]map[string]float64{
+				fooDriver: {
+					"pool1": 0.25,
+				},
+			},
+			wantHighestUtilization:     0.25,
+			wantHighestUtilizationName: apiv1.ResourceName(fmt.Sprintf("%s/%s", fooDriver, "pool1")),
+		},
 	} {
 		if tc.testName != "" {
 			continue
@@ -212,22 +231,22 @@ func testResourceSlices(driverName, poolName, nodeName string, poolGen, deviceCo
 	return result
 }
 
-func testResourceSlicesWithPartionableDevices(driverName, poolName, nodeName string, poolGen, partitionCount int) []*resourceapi.ResourceSlice {
+func testResourceSlicesWithPartionableDevices(driverName, poolName, deviceName, nodeName string, poolGen, partitionCount int) []*resourceapi.ResourceSlice {
 	sliceName := fmt.Sprintf("%s-%s-slice", driverName, poolName)
 	var devices []resourceapi.Device
 	for i := 0; i < partitionCount; i++ {
 		devices = append(
 			devices,
 			resourceapi.Device{
-				Name: fmt.Sprintf("gpu-0-partition-%d", i),
+				Name: fmt.Sprintf("%s-partition-%d", deviceName, i),
 				Capacity: map[resourceapi.QualifiedName]resourceapi.DeviceCapacity{
 					"memory": {
 						Value: resource.MustParse("10Gi"),
 					},
 				},
 				ConsumesCounters: []resourceapi.DeviceCounterConsumption{
 					{
-						CounterSet: "gpu-0-counter-set",
+						CounterSet: fmt.Sprintf("%s-counter-set", deviceName),
 						Counters: map[string]resourceapi.Counter{
 							"memory": {
 								Value: resource.MustParse("10Gi"),
@@ -240,15 +259,15 @@ func testResourceSlicesWithPartionableDevices(driverName, poolName, nodeName str
 	}
 	devices = append(devices,
 		resourceapi.Device{
-			Name: "gpu-0",
+			Name: deviceName,
 			Capacity: map[resourceapi.QualifiedName]resourceapi.DeviceCapacity{
 				"memory": {
 					Value: resource.MustParse(fmt.Sprintf("%dGi", 10*partitionCount)),
 				},
 			},
 			ConsumesCounters: []resourceapi.DeviceCounterConsumption{
 				{
-					CounterSet: "gpu-0-counter-set",
+					CounterSet: fmt.Sprintf("%s-counter-set", deviceName),
 					Counters: map[string]resourceapi.Counter{
 						"memory": {
 							Value: resource.MustParse(fmt.Sprintf("%dGi", 10*partitionCount)),