fix(2785): performance cores showing 75% instead of 100% when fully utilized

Modules/CPU/readers.swift

@@ -12,6 +12,30 @@
 import Cocoa
 import Kit
 
+public func calculatePerformanceCoresUsage(cores: [core_s], usagePerCore: [Double]) -> Double? {
+    guard cores.count == usagePerCore.count else { return nil }
+    let pCoresList: [Double] = cores.enumerated().compactMap { (index, core) -> Double? in
+        guard core.type == .performance, index < usagePerCore.count else {
+            return nil
+        }
+        return usagePerCore[index]
+    }
+    guard !pCoresList.isEmpty else { return nil }
+    return pCoresList.reduce(0, +) / Double(pCoresList.count)
+}
+
+public func calculateEfficiencyCoresUsage(cores: [core_s], usagePerCore: [Double]) -> Double? {
+    guard cores.count == usagePerCore.count else { return nil }
+    let eCoresList: [Double] = cores.enumerated().compactMap { (index, core) -> Double? in
+        guard core.type == .efficiency, index < usagePerCore.count else {
+            return nil
+        }
+        return usagePerCore[index]
+    }
+    guard !eCoresList.isEmpty else { return nil }
+    return eCoresList.reduce(0, +) / Double(eCoresList.count)
+}
+
 internal class LoadReader: Reader<CPU_Load> {
     private var cpuInfo: processor_info_array_t!
     private var prevCpuInfo: processor_info_array_t?
@@ -130,21 +154,8 @@ internal class LoadReader: Reader<CPU_Load> {
         self.response.totalUsage = self.response.systemLoad + self.response.userLoad
 
         if let cores = self.cores {
-            let eCoresList: [Double] = cores.filter({ $0.type == .efficiency }).compactMap { (c: core_s) in
-                if self.response.usagePerCore.indices.contains(Int(c.id)) {
-                    return self.response.usagePerCore[Int(c.id)]
-                }
-                return 0
-            }
-            let pCoresList: [Double] = cores.filter({ $0.type == .performance }).compactMap { (c: core_s) in
-                if self.response.usagePerCore.indices.contains(Int(c.id)) {
-                    return self.response.usagePerCore[Int(c.id)]
-                }
-                return 0
-            }
-
-            self.response.usageECores = eCoresList.reduce(0, +)/Double(eCoresList.count)
-            self.response.usagePCores = pCoresList.reduce(0, +)/Double(pCoresList.count)
+            self.response.usageECores = calculateEfficiencyCoresUsage(cores: cores, usagePerCore: self.response.usagePerCore)
+            self.response.usagePCores = calculatePerformanceCoresUsage(cores: cores, usagePerCore: self.response.usagePerCore)
         }
 
         self.callback(self.response)

Stats.xcodeproj/project.pbxproj

@@ -7,6 +7,7 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
+		11426C9F2EC374BC00EFF024 /* CPU.swift in Sources */ = {isa = PBXBuildFile; fileRef = 11426C9E2EC374BC00EFF024 /* CPU.swift */; };
 		5C038CF62D86EE8A00516809 /* Remote.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5C038CF52D86EE8700516809 /* Remote.swift */; };
 		5C044F7A2B3DE6F3005F6951 /* portal.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5C044F792B3DE6F3005F6951 /* portal.swift */; };
 		5C0A2A8A292A5B4D009B4C1F /* SMJobBlessUtil.py in Resources */ = {isa = PBXBuildFile; fileRef = 5C0A2A89292A5B4D009B4C1F /* SMJobBlessUtil.py */; };
@@ -489,6 +490,7 @@
 
 /* Begin PBXFileReference section */
 		0192A7ED2B017E190056F918 /* hi */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = hi; path = hi.lproj/Localizable.strings; sourceTree = "<group>"; };
+		11426C9E2EC374BC00EFF024 /* CPU.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CPU.swift; sourceTree = "<group>"; };
 		13BE56042D0E6963001C58EC /* en-AU */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = "en-AU"; path = "en-AU.lproj/Localizable.strings"; sourceTree = "<group>"; };
 		2658929724FC0F3B00FB3B6A /* zh-Hans */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = "zh-Hans"; path = "zh-Hans.lproj/Localizable.strings"; sourceTree = "<group>"; };
 		29AA17CA2926879000709C01 /* fa */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = fa; path = fa.lproj/Localizable.strings; sourceTree = "<group>"; };
@@ -1212,6 +1214,7 @@
 		9AAC5E2B280ACC120043D892 /* Tests */ = {
 			isa = PBXGroup;
 			children = (
+				11426C9E2EC374BC00EFF024 /* CPU.swift */,
 				9AAC5E2E280ACC120043D892 /* Info.plist */,
 				9AAC5E40280ACC210043D892 /* RAM.swift */,
 			);
@@ -2189,6 +2192,7 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				11426C9F2EC374BC00EFF024 /* CPU.swift in Sources */,
 				9AAC5E41280ACC210043D892 /* RAM.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;

Tests/CPU.swift

@@ -0,0 +1,222 @@
+//
+//  CPU.swift
+//  Tests
+//
+//  Created to test CPU performance cores utilization calculation fix.
+//  Testing issue #2785: Performance cores showing 75% instead of 100% when fully utilized.
+//
+//  Copyright © 2025. All rights reserved.
+//
+
+import XCTest
+import CPU
+import Kit
+
+class CPU: XCTestCase {
+
+    private func makeCore(id: Int32, type: coreType) -> core_s {
+        let json = """
+        {"id": \(id), "type": \(type.rawValue)}
+        """
+        guard let data = json.data(using: .utf8),
+              let core = try? JSONDecoder().decode(core_s.self, from: data) else {
+            fatalError("Failed to create core_s instance")
+        }
+        return core
+    }
+
+    func testPerformanceCoresShouldShow100Percent_Issue2785() throws {
+        let usagePerCore: [Double] = [
+            0.5, 0.5, 0.5, 0.5,
+            1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0
+        ]
+
+        let cores: [core_s] = [
+            makeCore(id: 0, type: coreType.efficiency),
+            makeCore(id: 1, type: coreType.efficiency),
+            makeCore(id: 2, type: coreType.efficiency),
+            makeCore(id: 3, type: coreType.efficiency),
+            makeCore(id: 4, type: coreType.performance),
+            makeCore(id: 5, type: coreType.performance),
+            makeCore(id: 6, type: coreType.performance),
+            makeCore(id: 7, type: coreType.performance),
+            makeCore(id: 8, type: coreType.performance),
+            makeCore(id: 9, type: coreType.performance),
+            makeCore(id: 20, type: coreType.performance),
+            makeCore(id: 21, type: coreType.performance)
+        ]
+
+        let usagePCores = calculatePerformanceCoresUsage(cores: cores, usagePerCore: usagePerCore)
+
+        XCTAssertNotNil(usagePCores, "Performance cores usage should be calculated")
+        XCTAssertEqual(usagePCores!, 1.0, accuracy: 0.01,
+                      "When all 8 performance cores are at 100%, should show 100%, not 75%")
+        XCTAssertEqual(cores.filter({ $0.type == .performance }).count, 8, "Should have 8 performance cores")
+    }
+
+    func testCalculatePerformanceCoresUsage_AllCoresAt100Percent() throws {
+        let cores: [core_s] = [
+            makeCore(id: 0, type: .efficiency),
+            makeCore(id: 1, type: .performance),
+            makeCore(id: 2, type: .performance),
+            makeCore(id: 3, type: .performance)
+        ]
+        let usagePerCore: [Double] = [0.5, 1.0, 1.0, 1.0]
+
+        let result = calculatePerformanceCoresUsage(cores: cores, usagePerCore: usagePerCore)
+
+        XCTAssertNotNil(result)
+        XCTAssertEqual(result!, 1.0, accuracy: 0.01, "All performance cores at 100% should return 100%")
+    }
+
+    func testCalculatePerformanceCoresUsage_MixedUsage() throws {
+        let cores: [core_s] = [
+            makeCore(id: 0, type: .efficiency),
+            makeCore(id: 1, type: .performance),
+            makeCore(id: 2, type: .performance),
+            makeCore(id: 3, type: .performance)
+        ]
+        let usagePerCore: [Double] = [0.5, 0.5, 0.75, 1.0]
+
+        let result = calculatePerformanceCoresUsage(cores: cores, usagePerCore: usagePerCore)
+
+        XCTAssertNotNil(result)
+        let expected = (0.5 + 0.75 + 1.0) / 3.0
+        XCTAssertEqual(result!, expected, accuracy: 0.01, "Should calculate average of performance cores")
+    }
+
+    func testCalculatePerformanceCoresUsage_NoPerformanceCores() throws {
+        let cores: [core_s] = [
+            makeCore(id: 0, type: .efficiency),
+            makeCore(id: 1, type: .efficiency),
+            makeCore(id: 2, type: .efficiency)
+        ]
+        let usagePerCore: [Double] = [0.5, 0.6, 0.7]
+
+        let result = calculatePerformanceCoresUsage(cores: cores, usagePerCore: usagePerCore)
+
+        XCTAssertNil(result, "Should return nil when there are no performance cores")
+    }
+
+    func testCalculatePerformanceCoresUsage_CountMismatch() throws {
+        let cores: [core_s] = [
+            makeCore(id: 0, type: .performance),
+            makeCore(id: 1, type: .performance)
+        ]
+        let usagePerCore: [Double] = [1.0, 1.0, 1.0]
+
+        let result = calculatePerformanceCoresUsage(cores: cores, usagePerCore: usagePerCore)
+
+        XCTAssertNil(result, "Should return nil when counts don't match")
+    }
+
+    func testCalculatePerformanceCoresUsage_EmptyArrays() throws {
+        let cores: [core_s] = []
+        let usagePerCore: [Double] = []
+
+        let result = calculatePerformanceCoresUsage(cores: cores, usagePerCore: usagePerCore)
+
+        XCTAssertNil(result, "Should return nil for empty arrays")
+    }
+
+    func testCalculatePerformanceCoresUsage_PositionalMatching() throws {
+        let cores: [core_s] = [
+            makeCore(id: 0, type: .efficiency),
+            makeCore(id: 5, type: .performance),
+            makeCore(id: 10, type: .performance),
+            makeCore(id: 20, type: .performance)
+        ]
+        let usagePerCore: [Double] = [0.3, 0.8, 0.9, 1.0]
+
+        let result = calculatePerformanceCoresUsage(cores: cores, usagePerCore: usagePerCore)
+
+        XCTAssertNotNil(result)
+        let expected = (0.8 + 0.9 + 1.0) / 3.0
+        XCTAssertEqual(result!, expected, accuracy: 0.01, "Should use positional matching, not ID-based")
+    }
+
+    func testCalculateEfficiencyCoresUsage_AllCoresAt50Percent() throws {
+        let cores: [core_s] = [
+            makeCore(id: 0, type: .efficiency),
+            makeCore(id: 1, type: .efficiency),
+            makeCore(id: 2, type: .performance),
+            makeCore(id: 3, type: .performance)
+        ]
+        let usagePerCore: [Double] = [0.5, 0.5, 1.0, 1.0]
+
+        let result = calculateEfficiencyCoresUsage(cores: cores, usagePerCore: usagePerCore)
+
+        XCTAssertNotNil(result)
+        XCTAssertEqual(result!, 0.5, accuracy: 0.01, "All efficiency cores at 50% should return 50%")
+    }
+
+    func testCalculateEfficiencyCoresUsage_MixedUsage() throws {
+        let cores: [core_s] = [
+            makeCore(id: 0, type: .efficiency),
+            makeCore(id: 1, type: .efficiency),
+            makeCore(id: 2, type: .efficiency),
+            makeCore(id: 3, type: .performance)
+        ]
+        let usagePerCore: [Double] = [0.3, 0.5, 0.7, 1.0]
+
+        let result = calculateEfficiencyCoresUsage(cores: cores, usagePerCore: usagePerCore)
+
+        XCTAssertNotNil(result)
+        let expected = (0.3 + 0.5 + 0.7) / 3.0
+        XCTAssertEqual(result!, expected, accuracy: 0.01, "Should calculate average of efficiency cores")
+    }
+
+    func testCalculateEfficiencyCoresUsage_NoEfficiencyCores() throws {
+        let cores: [core_s] = [
+            makeCore(id: 0, type: .performance),
+            makeCore(id: 1, type: .performance),
+            makeCore(id: 2, type: .performance)
+        ]
+        let usagePerCore: [Double] = [1.0, 1.0, 1.0]
+
+        let result = calculateEfficiencyCoresUsage(cores: cores, usagePerCore: usagePerCore)
+
+        XCTAssertNil(result, "Should return nil when there are no efficiency cores")
+    }
+
+    func testCalculateEfficiencyCoresUsage_CountMismatch() throws {
+        let cores: [core_s] = [
+            makeCore(id: 0, type: .efficiency),
+            makeCore(id: 1, type: .efficiency)
+        ]
+        let usagePerCore: [Double] = [0.5, 0.6, 0.7]
+
+        let result = calculateEfficiencyCoresUsage(cores: cores, usagePerCore: usagePerCore)
+
+        XCTAssertNil(result, "Should return nil when counts don't match")
+    }
+
+    func testCalculateEfficiencyCoresUsage_PositionalMatching() throws {
+        let cores: [core_s] = [
+            makeCore(id: 100, type: .efficiency),
+            makeCore(id: 200, type: .efficiency),
+            makeCore(id: 300, type: .performance)
+        ]
+        let usagePerCore: [Double] = [0.4, 0.6, 1.0]
+
+        let result = calculateEfficiencyCoresUsage(cores: cores, usagePerCore: usagePerCore)
+
+        XCTAssertNotNil(result)
+        let expected = (0.4 + 0.6) / 2.0
+        XCTAssertEqual(result!, expected, accuracy: 0.01, "Should use positional matching, not ID-based")
+    }
+
+    func testCalculateEfficiencyCoresUsage_ZeroUsage() throws {
+        let cores: [core_s] = [
+            makeCore(id: 0, type: .efficiency),
+            makeCore(id: 1, type: .efficiency),
+            makeCore(id: 2, type: .performance)
+        ]
+        let usagePerCore: [Double] = [0.0, 0.0, 1.0]
+
+        let result = calculateEfficiencyCoresUsage(cores: cores, usagePerCore: usagePerCore)
+
+        XCTAssertNotNil(result)
+        XCTAssertEqual(result!, 0.0, accuracy: 0.01, "Should handle zero usage correctly")
+    }
+}