Calculate effective capacity from overcommit and capacity (#70)

In cobaltcore-dev/openstack-hypervisor-operator#257 we add a spec field that can be used to specify the desired overcommit ratio for each resource name. This change applies the overcommit ratio to the hypervisor to its status, by calculating the effective capacity and exposing it through the hypervisor status.

Author: PhilippMatthes

go.mod

@@ -7,7 +7,7 @@ go 1.26
 
 require (
 	github.com/cert-manager/cert-manager v1.19.4
-	github.com/cobaltcore-dev/openstack-hypervisor-operator v0.0.0-20260309144200-9c8ed613a94c
+	github.com/cobaltcore-dev/openstack-hypervisor-operator v0.0.0-20260313120621-e3699e2ccab9
 	github.com/coreos/go-systemd/v22 v22.7.0
 	github.com/digitalocean/go-libvirt v0.0.0-20260217163227-273eaa321819
 	github.com/godbus/dbus/v5 v5.2.2

go.sum

@@ -16,6 +16,8 @@ github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UF
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cobaltcore-dev/openstack-hypervisor-operator v0.0.0-20260309144200-9c8ed613a94c h1:KylfcJikSMWNJnuNfG1Od6fNUw4kQTjseP7khmwVlrM=
 github.com/cobaltcore-dev/openstack-hypervisor-operator v0.0.0-20260309144200-9c8ed613a94c/go.mod h1:b0KmJdxvRI8UXlGe8cRm5BD8Tm2WhF7zSKMSIRGyVL4=
+github.com/cobaltcore-dev/openstack-hypervisor-operator v0.0.0-20260313120621-e3699e2ccab9 h1:fIQCfP6HTOMu9XqcRLUYeUCK2mPWcOkSqYVF9HUhQyE=
+github.com/cobaltcore-dev/openstack-hypervisor-operator v0.0.0-20260313120621-e3699e2ccab9/go.mod h1:b0KmJdxvRI8UXlGe8cRm5BD8Tm2WhF7zSKMSIRGyVL4=
 github.com/coreos/go-systemd/v22 v22.7.0 h1:LAEzFkke61DFROc7zNLX/WA2i5J8gYqe0rSj9KI28KA=
 github.com/coreos/go-systemd/v22 v22.7.0/go.mod h1:xNUYtjHu2EDXbsxz1i41wouACIwT7Ybq9o0BQhMwD0w=
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=

internal/libvirt/libvirt.go

@@ -274,6 +274,7 @@ func (l *LibVirt) Process(hv v1.Hypervisor) (v1.Hypervisor, error) {
 		l.addCapabilities,
 		l.addDomainCapabilities,
 		l.addAllocationCapacity,
+		l.addEffectiveCapacity,
 	}
 	var err error
 	for _, processor := range processors {
@@ -458,14 +459,14 @@ func (l *LibVirt) addAllocationCapacity(old v1.Hypervisor) (v1.Hypervisor, error
 
 		cellsById[cell.ID] = v1.Cell{
 			CellID: cell.ID,
-			Allocation: map[string]resource.Quantity{
+			Allocation: map[v1.ResourceName]resource.Quantity{
 				// Will be updated below when we look at the domain infos.
-				"memory": *resource.NewQuantity(0, resource.BinarySI),
-				"cpu":    *resource.NewQuantity(0, resource.DecimalSI),
+				v1.ResourceMemory: *resource.NewQuantity(0, resource.BinarySI),
+				v1.ResourceCPU:    *resource.NewQuantity(0, resource.DecimalSI),
 			},
-			Capacity: map[string]resource.Quantity{
-				"memory": memoryCapacity,
-				"cpu":    cpuCapacity,
+			Capacity: map[v1.ResourceName]resource.Quantity{
+				v1.ResourceMemory: memoryCapacity,
+				v1.ResourceCPU:    cpuCapacity,
 			},
 		}
 	}
@@ -505,14 +506,14 @@ func (l *LibVirt) addAllocationCapacity(old v1.Hypervisor) (v1.Hypervisor, error
 					domInfo.Name, memoryNode.CellID,
 				)
 			}
-			memAllocCell := cell.Allocation["memory"]
+			memAllocCell := cell.Allocation[v1.ResourceMemory]
 			// If a domain is using multiple memory cells, assume the
 			// distribution across cells is even.
 			nCells := int64(len(domInfo.NumaTune.MemNodes)) // is non-zero
 			memAllocPerCell := *resource.
 				NewQuantity(memAlloc.Value()/nCells, resource.BinarySI)
 			memAllocCell.Add(memAllocPerCell)
-			cell.Allocation["memory"] = memAllocCell
+			cell.Allocation[v1.ResourceMemory] = memAllocCell
 			cellsById[memoryNode.CellID] = cell
 		}
 
@@ -528,14 +529,14 @@ func (l *LibVirt) addAllocationCapacity(old v1.Hypervisor) (v1.Hypervisor, error
 					domInfo.Name, cpuCell.ID,
 				)
 			}
-			cpuAllocCell := cell.Allocation["cpu"]
+			cpuAllocCell := cell.Allocation[v1.ResourceCPU]
 			// If a domain is using multiple cpu cells, assume the distribution
 			// across cells is even.
 			nCells := int64(len(domInfo.CPU.Numa.Cells)) // is non-zero
 			cpuAllocPerCell := *resource.
 				NewQuantity(cpuAlloc.Value()/nCells, resource.DecimalSI)
 			cpuAllocCell.Add(cpuAllocPerCell)
-			cell.Allocation["cpu"] = cpuAllocCell
+			cell.Allocation[v1.ResourceCPU] = cpuAllocCell
 			cellsById[cpuCell.ID] = cell
 		}
 	}
@@ -544,12 +545,48 @@ func (l *LibVirt) addAllocationCapacity(old v1.Hypervisor) (v1.Hypervisor, error
 		cellsAsSlice = append(cellsAsSlice, cell)
 	}
 
-	newHv.Status.Capacity = make(map[string]resource.Quantity)
-	newHv.Status.Capacity["memory"] = *totalMemoryCapacity
-	newHv.Status.Capacity["cpu"] = *totalCpuCapacity
-	newHv.Status.Allocation = make(map[string]resource.Quantity)
-	newHv.Status.Allocation["memory"] = *totalMemoryAlloc
-	newHv.Status.Allocation["cpu"] = *totalCpuAlloc
+	newHv.Status.Capacity = make(map[v1.ResourceName]resource.Quantity)
+	newHv.Status.Capacity[v1.ResourceMemory] = *totalMemoryCapacity
+	newHv.Status.Capacity[v1.ResourceCPU] = *totalCpuCapacity
+	newHv.Status.Allocation = make(map[v1.ResourceName]resource.Quantity)
+	newHv.Status.Allocation[v1.ResourceMemory] = *totalMemoryAlloc
+	newHv.Status.Allocation[v1.ResourceCPU] = *totalCpuAlloc
 	newHv.Status.Cells = cellsAsSlice
 	return newHv, nil
 }
+
+// Add the effective capacity to the hypervisor instance.
+//
+// The effective capacity is calculated as the physical capacity times the
+// applied overcommit ratio, or 1.0 by default. In case the resulting values
+// are fractional, they are floored.
+func (l *LibVirt) addEffectiveCapacity(old v1.Hypervisor) (v1.Hypervisor, error) {
+	newHv := *old.DeepCopy()
+	// Always recreate the EffectiveCapacity map to remove stale entries
+	newHv.Status.EffectiveCapacity = make(map[v1.ResourceName]resource.Quantity)
+	for resourceName, capacity := range newHv.Status.Capacity {
+		overcommit, ok := newHv.Spec.Overcommit[resourceName]
+		if !ok {
+			overcommit = 1.0
+		}
+		flooredValue := int64(float64(capacity.Value()) * overcommit)
+		effectiveCapacity := resource.NewQuantity(flooredValue, capacity.Format)
+		newHv.Status.EffectiveCapacity[resourceName] = *effectiveCapacity
+	}
+	// Also apply this to each cell.
+	for i, cell := range newHv.Status.Cells {
+		// Always recreate the cell's EffectiveCapacity map to remove stale entries
+		cell.EffectiveCapacity = make(map[v1.ResourceName]resource.Quantity)
+		for resourceName, capacity := range cell.Capacity {
+			overcommit, ok := newHv.Spec.Overcommit[resourceName]
+			if !ok {
+				overcommit = 1.0
+			}
+			flooredValue := int64(float64(capacity.Value()) * overcommit)
+			effectiveCapacity := resource.NewQuantity(flooredValue, capacity.Format)
+			cell.EffectiveCapacity[resourceName] = *effectiveCapacity
+		}
+		newHv.Status.Cells[i] = cell
+	}
+	return newHv, nil
+}