Make capping happen after scale of the CPU usage in ResourceUtilizati…

…on (#5388)
dotnet · Sep 4, 2024 · dc1ba70 · dc1ba70
1 parent 45e8ca3
commit dc1ba70
Show file tree

Hide file tree

Showing 3 changed files with 30 additions and 28 deletions.
diff --git a/src/Libraries/Microsoft.Extensions.Diagnostics.ResourceMonitoring/Calculator.cs b/src/Libraries/Microsoft.Extensions.Diagnostics.ResourceMonitoring/Calculator.cs
@@ -38,8 +38,7 @@ public static ResourceUtilization CalculateUtilization(in Snapshot first, in Sna
         long newUsageTicks = second.KernelTimeSinceStart.Ticks + second.UserTimeSinceStart.Ticks;
         long totalUsageTickDelta = newUsageTicks - oldUsageTicks;
 
-        var utilization = Math.Max(0.0, totalUsageTickDelta / totalSystemTicks * Hundred);
-        var cpuUtilization = Math.Min(Hundred, utilization);
+        double cpuUtilization = Math.Max(0.0, totalUsageTickDelta / totalSystemTicks * Hundred);
 
         return new ResourceUtilization(cpuUtilization, second.MemoryUsageInBytes, systemResources, second);
     }

diff --git a/src/Libraries/Microsoft.Extensions.Diagnostics.ResourceMonitoring/ResourceUtilization.cs b/src/Libraries/Microsoft.Extensions.Diagnostics.ResourceMonitoring/ResourceUtilization.cs
@@ -62,7 +62,7 @@ public ResourceUtilization(double cpuUsedPercentage, ulong memoryUsedInBytes, Sy
             guaranteedCpuUnits = 1;
         }
 
-        CpuUsedPercentage = Throw.IfLessThan(cpuUsedPercentage / guaranteedCpuUnits, 0.0);
+        CpuUsedPercentage = Math.Min(Hundred, Throw.IfLessThan(cpuUsedPercentage / guaranteedCpuUnits, 0.0));
         MemoryUsedInBytes = Throw.IfLessThan(memoryUsedInBytes, 0);
         SystemResources = systemResources;
         MemoryUsedPercentage = Math.Min(Hundred, (double)MemoryUsedInBytes / systemResources.GuaranteedMemoryInBytes * Hundred);

diff --git a/test/Libraries/Microsoft.Extensions.Diagnostics.ResourceMonitoring.Tests/CalculatorTests.cs b/test/Libraries/Microsoft.Extensions.Diagnostics.ResourceMonitoring.Tests/CalculatorTests.cs
@@ -28,12 +28,12 @@ public sealed class CalculatorTests
     [Fact]
     public void BasicCalculation()
     {
-        var secondSnapshotTimeSpan = _firstSnapshot.TotalTimeSinceStart.Add(TimeSpan.FromSeconds(5));
+        TimeSpan secondSnapshotTimeSpan = _firstSnapshot.TotalTimeSinceStart.Add(TimeSpan.FromSeconds(5));
 
         // Now, what's the total number of available ticks between the two samples (for a single core)
-        var totalAvailableTicks = secondSnapshotTimeSpan.Ticks - _firstSnapshot.TotalTimeSinceStart.Ticks;
+        long totalAvailableTicks = secondSnapshotTimeSpan.Ticks - _firstSnapshot.TotalTimeSinceStart.Ticks;
 
-        var second = new Snapshot(
+        Snapshot second = new(
             totalTimeSinceStart: secondSnapshotTimeSpan,
 
             // assign 25% to kernel time
@@ -44,7 +44,7 @@ public void BasicCalculation()
             memoryUsageInBytes: 500);
 
         // Now, when we run the calculator, CPU should be at 50%.
-        var record = Calculator.CalculateUtilization(_firstSnapshot, second, _resources);
+        ResourceUtilization record = Calculator.CalculateUtilization(_firstSnapshot, second, _resources);
         Assert.Equal(50.0, record.CpuUsedPercentage);
 
         // Because we set it basically, memory should also clearly be at 50%.
@@ -61,14 +61,14 @@ public void BasicCalculation()
     [Fact]
     public void BasicCalculation_WithHalfCpuUnits()
     {
-        var limitedResources = new SystemResources(0.5, 0.5, TotalMemoryInBytes, TotalMemoryInBytes);
+        SystemResources limitedResources = new(guaranteedCpuUnits: 0.5, maximumCpuUnits: 0.5, TotalMemoryInBytes, TotalMemoryInBytes);
 
-        var secondSnapshotTimeSpan = _firstSnapshot.TotalTimeSinceStart.Add(TimeSpan.FromSeconds(5));
+        TimeSpan secondSnapshotTimeSpan = _firstSnapshot.TotalTimeSinceStart.Add(TimeSpan.FromSeconds(5));
 
         // Now, what's the total number of available ticks between the two samples (for a single core)
-        var totalAvailableTicks = secondSnapshotTimeSpan.Ticks - _firstSnapshot.TotalTimeSinceStart.Ticks;
+        long totalAvailableTicks = secondSnapshotTimeSpan.Ticks - _firstSnapshot.TotalTimeSinceStart.Ticks;
 
-        var second = new Snapshot(
+        Snapshot second = new(
             totalTimeSinceStart: secondSnapshotTimeSpan,
 
             // assign 25% to kernel time
@@ -80,7 +80,7 @@ public void BasicCalculation_WithHalfCpuUnits()
 
         // Using the limited resources, CPU time is now cut in half. So, when we run
         // the calculator, the CPU utilization should be at 100%.
-        var record = Calculator.CalculateUtilization(_firstSnapshot, second, limitedResources);
+        ResourceUtilization record = Calculator.CalculateUtilization(_firstSnapshot, second, limitedResources);
         Assert.Equal(100.0, record.CpuUsedPercentage);
     }
 
@@ -91,7 +91,7 @@ public void BasicCalculation_WithHalfCpuUnits()
     public void Zeroes()
     {
         // No changes in the second snapshot
-        var secondSnapshot = new Snapshot(
+        Snapshot secondSnapshot = new(
             totalTimeSinceStart: _firstSnapshot.TotalTimeSinceStart.Add(TimeSpan.FromSeconds(5)),
             memoryUsageInBytes: 0,
             kernelTimeSinceStart: _firstSnapshot.KernelTimeSinceStart,
@@ -100,7 +100,7 @@ public void Zeroes()
         // Now, let's set each of kernel and user time to no time elapsed.
 
         // Now, when we run the calculator, CPU should be at 0%.
-        var record = Calculator.CalculateUtilization(_firstSnapshot, secondSnapshot, _resources);
+        ResourceUtilization record = Calculator.CalculateUtilization(_firstSnapshot, secondSnapshot, _resources);
         Assert.Equal(0.0, record.CpuUsedPercentage);
 
         // Because we set it basically, memory should also clearly be at 0%.
@@ -118,19 +118,19 @@ public void Zeroes()
     [Fact]
     public void TimeGoesBackwards()
     {
-        var firstSnapshot = new Snapshot(
+        Snapshot firstSnapshot = new(
         totalTimeSinceStart: TimeSpan.FromTicks(new FakeTimeProvider().GetUtcNow().Ticks),
         kernelTimeSinceStart: TimeSpan.FromTicks(1000),
         userTimeSinceStart: TimeSpan.FromTicks(1000),
         memoryUsageInBytes: 0);
-        var secondSnapshot = new Snapshot(
+        Snapshot secondSnapshot = new(
             totalTimeSinceStart: firstSnapshot.TotalTimeSinceStart.Add(TimeSpan.FromSeconds(5)),
             memoryUsageInBytes: 0,
             kernelTimeSinceStart: TimeSpan.FromTicks(firstSnapshot.KernelTimeSinceStart.Ticks - 1),
             userTimeSinceStart: TimeSpan.FromTicks(firstSnapshot.UserTimeSinceStart.Ticks - 1));
 
         // Now, when we run the calculator, CPU should be at 0%.
-        var record = Calculator.CalculateUtilization(firstSnapshot, secondSnapshot, _resources);
+        ResourceUtilization record = Calculator.CalculateUtilization(firstSnapshot, secondSnapshot, _resources);
         Assert.Equal(0.0, record.CpuUsedPercentage);
     }
 
@@ -141,19 +141,19 @@ public void TimeGoesBackwards()
     [Fact]
     public void FullyUtilized()
     {
-        var secondSnapshotTimeSpan = _firstSnapshot.TotalTimeSinceStart.Add(TimeSpan.FromSeconds(5));
+        TimeSpan secondSnapshotTimeSpan = _firstSnapshot.TotalTimeSinceStart.Add(TimeSpan.FromSeconds(5));
 
         // Now, what's the total number of available ticks between the two samples.
-        var totalAvailableTicks = secondSnapshotTimeSpan.Ticks - _firstSnapshot.TotalTimeSinceStart.Ticks;
+        long totalAvailableTicks = secondSnapshotTimeSpan.Ticks - _firstSnapshot.TotalTimeSinceStart.Ticks;
 
-        var secondSnapshot = new Snapshot(
+        Snapshot secondSnapshot = new(
             totalTimeSinceStart: secondSnapshotTimeSpan,
             kernelTimeSinceStart: TimeSpan.FromTicks(totalAvailableTicks / 2),
             userTimeSinceStart: TimeSpan.FromTicks(totalAvailableTicks / 2),
             memoryUsageInBytes: 1000);
 
         // Now, when we run the calculator, CPU should 100%.
-        var record = Calculator.CalculateUtilization(_firstSnapshot, secondSnapshot, _resources);
+        ResourceUtilization record = Calculator.CalculateUtilization(_firstSnapshot, secondSnapshot, _resources);
         Assert.Equal(100.0, record.CpuUsedPercentage);
 
         // Assert that memory is at 100%.
@@ -166,15 +166,18 @@ public void FullyUtilized()
     /// Ensure that stats work appropriately if the resources are overutilized.
     /// </summary>
     /// <remarks>The highest possible CPU and memory percentages should be 100%.</remarks>
-    [Fact]
-    public void OverUtilized()
+    [Theory]
+    [InlineData(1, 100.0)]
+    [InlineData(2, 100.0)]
+    public void OverUtilized(double cpuUnits, double expectedCpuUsage)
     {
-        var secondSnapshotTimeSpan = _firstSnapshot.TotalTimeSinceStart.Add(TimeSpan.FromSeconds(5));
+        SystemResources limitedResources = new(cpuUnits, cpuUnits, TotalMemoryInBytes, TotalMemoryInBytes);
+        TimeSpan secondSnapshotTimeSpan = _firstSnapshot.TotalTimeSinceStart.Add(TimeSpan.FromSeconds(5));
 
         // Now, what's the total number of available ticks between the two samples.
-        var totalAvailableTicks = secondSnapshotTimeSpan.Ticks - _firstSnapshot.TotalTimeSinceStart.Ticks;
+        long totalAvailableTicks = secondSnapshotTimeSpan.Ticks - _firstSnapshot.TotalTimeSinceStart.Ticks;
 
-        var secondSnapshot = new Snapshot(
+        Snapshot secondSnapshot = new(
             totalTimeSinceStart: secondSnapshotTimeSpan,
 
             // Set each of kernel and uesr time to all the available ticks between
@@ -184,8 +187,8 @@ public void OverUtilized()
             memoryUsageInBytes: 1500);
 
         // Now, when we run the calculator, CPU should be at 100%.
-        var record = Calculator.CalculateUtilization(_firstSnapshot, secondSnapshot, _resources);
-        Assert.Equal(100.0, record.CpuUsedPercentage);
+        ResourceUtilization record = Calculator.CalculateUtilization(_firstSnapshot, secondSnapshot, _resources);
+        Assert.Equal(expectedCpuUsage, record.CpuUsedPercentage);
 
         // Assert that memory is at 100%
         Assert.Equal(100.0, record.MemoryUsedPercentage);