From 6bd112cbd15a6aa542846e050c1ccab6767a1781 Mon Sep 17 00:00:00 2001 From: Nick Wolff Date: Thu, 12 Nov 2026 10:39:39 -0500 Subject: [PATCH 1/2] fix(cpu): classify M5 Super and Performance cores - Add a Super core kind and class perflevels by hw.perflevelN.name - Map device tree cluster types E, M, P to perflevels by tier - Show Super cores in the dashboard core grid and summary rows - Cover M1-M4, base M5, M5 Pro/Max, and multi-die layouts in tests --- App/Dashboard/CPUSection.swift | 6 +- .../BarometryKit/Model/CPUSample.swift | 12 ++- .../BarometryKit/Platform/CoreTopology.swift | 91 ++++++++++++++----- .../BarometryKit/Samplers/CPUSampler.swift | 2 +- .../BarometryKitTests/CPUSampleTests.swift | 70 +++++++++++++- 5 files changed, 154 insertions(+), 27 deletions(-) diff --git a/App/Dashboard/CPUSection.swift b/App/Dashboard/CPUSection.swift index eb57911..3183f31 100644 --- a/App/Dashboard/CPUSection.swift +++ b/App/Dashboard/CPUSection.swift @@ -45,7 +45,7 @@ struct CPUDetails: View { } DetailsHeading("Cores") CoreGrid(cores: cpu.cores) - ForEach([CoreKind.efficiency, .performance], id: \.self) { kind in + ForEach(CoreKind.allCases, id: \.self) { kind in if let average = cpu.averageLoad(of: kind) { let count = cpu.cores.count { $0.kind == kind } DetailRow( @@ -86,7 +86,7 @@ private struct LoadChart: View { } } -/// One cell per core, shaded by load, with efficiency cores first. +/// One cell per core, shaded by load, with the slowest cores first. private struct CoreGrid: View { let cores: [CoreLoad] @@ -125,6 +125,7 @@ private extension CoreKind { switch self { case .efficiency: "Efficiency" case .performance: "Performance" + case .super: "Super" } } @@ -132,6 +133,7 @@ private extension CoreKind { switch self { case .efficiency: "E" case .performance: "P" + case .super: "S" } } } diff --git a/Packages/BarometryKit/Sources/BarometryKit/Model/CPUSample.swift b/Packages/BarometryKit/Sources/BarometryKit/Model/CPUSample.swift index 8ed75d8..f5e87d0 100644 --- a/Packages/BarometryKit/Sources/BarometryKit/Model/CPUSample.swift +++ b/Packages/BarometryKit/Sources/BarometryKit/Model/CPUSample.swift @@ -1,9 +1,19 @@ // SPDX-FileCopyrightText: 2026 Nick Wolff // SPDX-License-Identifier: GPL-3.0-only -public enum CoreKind: Sendable { +public enum CoreKind: Sendable, CaseIterable { case efficiency case performance + case `super` + + init?(perflevelName: String) { + switch perflevelName { + case "Efficiency": self = .efficiency + case "Performance": self = .performance + case "Super": self = .super + default: return nil + } + } } /// Cumulative scheduler ticks for one logical CPU since boot. diff --git a/Packages/BarometryKit/Sources/BarometryKit/Platform/CoreTopology.swift b/Packages/BarometryKit/Sources/BarometryKit/Platform/CoreTopology.swift index e4f54cf..8e55029 100644 --- a/Packages/BarometryKit/Sources/BarometryKit/Platform/CoreTopology.swift +++ b/Packages/BarometryKit/Sources/BarometryKit/Platform/CoreTopology.swift @@ -4,26 +4,77 @@ import Foundation import IOKit -enum CoreTopology { +struct CoreTopology: Equatable { + struct PerfLevel: Equatable { + let kind: CoreKind + let logicalCPUs: Int + } + + struct CPUNode: Equatable { + let logicalID: Int + let clusterID: Int? + let clusterType: Character + } + + struct Cluster: Equatable { + let id: Int + let type: Character + let kind: CoreKind + } + /// Core kinds indexed by logical CPU number. - static func current() -> [CoreKind] { - if let kinds = deviceTreeKinds() { - return kinds + let kinds: [CoreKind] + let clusters: [Cluster] + + static func current() -> CoreTopology { + let levels = perfLevels() + if let cpus = deviceTreeCPUs(), let topology = CoreTopology(cpus: cpus, levels: levels) { + return topology } - let performance = Sysctl.integer("hw.perflevel0.logicalcpu", as: Int32.self) - ?? Sysctl.integer("hw.ncpu", as: Int32.self) - ?? 0 - let efficiency = Sysctl.integer("hw.perflevel1.logicalcpu", as: Int32.self) ?? 0 - return fallbackKinds(efficiency: Int(efficiency), performance: Int(performance)) + return CoreTopology(levels: levels) } - /// Apple Silicon numbers efficiency cores before performance cores. - static func fallbackKinds(efficiency: Int, performance: Int) -> [CoreKind] { - Array(repeating: .efficiency, count: max(efficiency, 0)) + Array(repeating: .performance, count: max(performance, 0)) + /// Apple Silicon numbers its slowest cores first. + init(levels: [PerfLevel]) { + kinds = levels.reversed().flatMap { Array(repeating: $0.kind, count: max($0.logicalCPUs, 0)) } + clusters = [] } - /// Reads each `IODeviceTree:/cpus/cpuN` node's `logical-cpu-id` and `cluster-type` ("E" or "P"). - private static func deviceTreeKinds() -> [CoreKind]? { + init?(cpus: [CPUNode], levels: [PerfLevel]) { + let clusterTypesSlowestFirst: [Character] = ["E", "M", "P"] + let types = Set(cpus.map(\.clusterType)) + guard !cpus.isEmpty, + types.isSubset(of: clusterTypesSlowestFirst), + types.count == levels.count, + Set(cpus.map(\.logicalID)) == Set(0.. [PerfLevel] { + let count = Int(Sysctl.integer("hw.nperflevels", as: Int32.self) ?? 0) + let levels = (0.. PerfLevel? in + guard let cpus = Sysctl.integer("hw.perflevel\(level).logicalcpu", as: Int32.self) else { return nil } + let kind = Sysctl.string("hw.perflevel\(level).name").flatMap(CoreKind.init(perflevelName:)) + ?? (level == 0 ? .performance : .efficiency) + return PerfLevel(kind: kind, logicalCPUs: Int(cpus)) + } + if levels.isEmpty, let cpus = Sysctl.integer("hw.ncpu", as: Int32.self) { + return [PerfLevel(kind: .performance, logicalCPUs: Int(cpus))] + } + return levels + } + + /// Reads each `IODeviceTree:/cpus/cpuN` node's `logical-cpu-id`, `cluster-id`, and `cluster-type`. + private static func deviceTreeCPUs() -> [CPUNode]? { let cpus = IORegistryEntryFromPath(kIOMainPortDefault, "IODeviceTree:/cpus") guard cpus != IO_OBJECT_NULL else { return nil } defer { IOObjectRelease(cpus) } @@ -32,18 +83,16 @@ enum CoreTopology { guard IORegistryEntryGetChildIterator(cpus, kIODeviceTreePlane, &iterator) == KERN_SUCCESS else { return nil } defer { IOObjectRelease(iterator) } - var kindsByID: [Int: CoreKind] = [:] + var nodes: [CPUNode] = [] while case let entry = IOIteratorNext(iterator), entry != IO_OBJECT_NULL { defer { IOObjectRelease(entry) } guard let id = property(entry, "logical-cpu-id") as? Int, - let clusterType = property(entry, "cluster-type") as? Data, - let first = clusterType.first + let clusterType = (property(entry, "cluster-type") as? Data)?.first else { continue } - kindsByID[id] = first == UInt8(ascii: "E") ? .efficiency : .performance + let clusterID = (property(entry, "cluster-id") as? Data)?.first.map(Int.init) + nodes.append(CPUNode(logicalID: id, clusterID: clusterID, clusterType: Character(UnicodeScalar(clusterType)))) } - - guard !kindsByID.isEmpty, Set(kindsByID.keys) == Set(0.. Any? { diff --git a/Packages/BarometryKit/Sources/BarometryKit/Samplers/CPUSampler.swift b/Packages/BarometryKit/Sources/BarometryKit/Samplers/CPUSampler.swift index db5791d..bd5070c 100644 --- a/Packages/BarometryKit/Sources/BarometryKit/Samplers/CPUSampler.swift +++ b/Packages/BarometryKit/Sources/BarometryKit/Samplers/CPUSampler.swift @@ -5,7 +5,7 @@ import Darwin struct CPUSampler { private let host = mach_host_self() - private let kinds = CoreTopology.current() + private let kinds = CoreTopology.current().kinds private var previous: [CPUTicks]? /// Returns nil on the first call, since load needs two readings. diff --git a/Packages/BarometryKit/Tests/BarometryKitTests/CPUSampleTests.swift b/Packages/BarometryKit/Tests/BarometryKitTests/CPUSampleTests.swift index 7566d45..d96e6a1 100644 --- a/Packages/BarometryKit/Tests/BarometryKitTests/CPUSampleTests.swift +++ b/Packages/BarometryKit/Tests/BarometryKitTests/CPUSampleTests.swift @@ -86,7 +86,73 @@ struct CPUSampleTests { #expect(sample.total == .idle) } - @Test func fallbackTopologyListsEfficiencyCoresFirst() { - #expect(CoreTopology.fallbackKinds(efficiency: 2, performance: 3) == [.efficiency, .efficiency, .performance, .performance, .performance]) + @Test func perflevelTopologyListsSlowestCoresFirst() { + let topology = CoreTopology(levels: [ + .init(kind: .super, logicalCPUs: 2), + .init(kind: .performance, logicalCPUs: 3), + ]) + + #expect(topology.kinds == [.performance, .performance, .performance, .super, .super]) + } + + @Test func m4ClusterTypesMapToEfficiencyAndPerformance() throws { + let topology = try #require(CoreTopology( + cpus: [cpu(0, cluster: 0, "E"), cpu(1, cluster: 1, "P")], + levels: [.init(kind: .performance, logicalCPUs: 1), .init(kind: .efficiency, logicalCPUs: 1)] + )) + + #expect(topology.kinds == [.efficiency, .performance]) + } + + @Test func m5MaxClusterTypesMapToPerformanceAndSuper() throws { + let topology = try #require(CoreTopology( + cpus: [cpu(0, cluster: 0, "M"), cpu(1, cluster: 1, "M"), cpu(2, cluster: 2, "P")], + levels: [.init(kind: .super, logicalCPUs: 1), .init(kind: .performance, logicalCPUs: 2)] + )) + + #expect(topology.kinds == [.performance, .performance, .super]) + #expect(topology.clusters == [ + .init(id: 0, type: "M", kind: .performance), + .init(id: 1, type: "M", kind: .performance), + .init(id: 2, type: "P", kind: .super), + ]) + } + + @Test func baseM5ClusterTypesMapToEfficiencyAndSuper() throws { + let topology = try #require(CoreTopology( + cpus: [cpu(0, cluster: 0, "E"), cpu(1, cluster: 1, "P")], + levels: [.init(kind: .super, logicalCPUs: 1), .init(kind: .efficiency, logicalCPUs: 1)] + )) + + #expect(topology.kinds == [.efficiency, .super]) + } + + @Test func clusterTypesFollowLogicalNumberingAcrossDies() throws { + let topology = try #require(CoreTopology( + cpus: [cpu(0, cluster: 0, "E"), cpu(1, cluster: 1, "P"), cpu(2, cluster: 2, "E"), cpu(3, cluster: 3, "P")], + levels: [.init(kind: .performance, logicalCPUs: 2), .init(kind: .efficiency, logicalCPUs: 2)] + )) + + #expect(topology.kinds == [.efficiency, .performance, .efficiency, .performance]) + } + + @Test func clusterTypesThatDisagreeWithPerflevelsAreRejected() { + let topology = CoreTopology( + cpus: [cpu(0, cluster: 0, "E"), cpu(1, cluster: 1, "P")], + levels: [.init(kind: .performance, logicalCPUs: 2)] + ) + + #expect(topology == nil) + } + + @Test func classifiesPerflevelNames() { + #expect(CoreKind(perflevelName: "Efficiency") == .efficiency) + #expect(CoreKind(perflevelName: "Performance") == .performance) + #expect(CoreKind(perflevelName: "Super") == .super) + #expect(CoreKind(perflevelName: "Turbo") == nil) + } + + private func cpu(_ id: Int, cluster: Int, _ type: Character) -> CoreTopology.CPUNode { + CoreTopology.CPUNode(logicalID: id, clusterID: cluster, clusterType: type) } } From 279d17519a2dafaaa0adcf9af6947e1af27dc63d Mon Sep 17 00:00:00 2001 From: Nick Wolff Date: Thu, 12 Nov 2026 10:39:39 -0500 Subject: [PATCH 2/2] fix(cpu): read clock speeds for every core tier - Report a frequency per core kind instead of fixed E and P fields - Read MCPU channels used by M5 Pro/Max Performance clusters - Find missing voltage-state tables through pmgr acc-clusters - Use the fastest active tier as the headline CPU clock --- App/Dashboard/CPUSection.swift | 6 +- .../BarometryKit/Model/SensorSample.swift | 17 +++--- .../Samplers/FrequencySampler.swift | 60 +++++++++++++------ .../Tests/BarometryKitTests/SensorTests.swift | 16 +++++ 4 files changed, 68 insertions(+), 31 deletions(-) diff --git a/App/Dashboard/CPUSection.swift b/App/Dashboard/CPUSection.swift index 3183f31..9b5506b 100644 --- a/App/Dashboard/CPUSection.swift +++ b/App/Dashboard/CPUSection.swift @@ -50,17 +50,13 @@ struct CPUDetails: View { let count = cpu.cores.count { $0.kind == kind } DetailRow( label: "\(kind.name) ยท \(count)", - value: summary(average.formatted(), frequency(of: kind)?.formatted()) ?? missingValue + value: summary(average.formatted(), frequencies?.cores[kind]?.formatted()) ?? missingValue ) } } AppList.byCPU(processes, tint: DashboardSection.cpu.tint) } } - - private func frequency(of kind: CoreKind) -> Frequency? { - kind == .efficiency ? frequencies?.efficiencyCores : frequencies?.performanceCores - } } /// Total load over the whole history, user stacked under system. diff --git a/Packages/BarometryKit/Sources/BarometryKit/Model/SensorSample.swift b/Packages/BarometryKit/Sources/BarometryKit/Model/SensorSample.swift index f1cfdac..475697c 100644 --- a/Packages/BarometryKit/Sources/BarometryKit/Model/SensorSample.swift +++ b/Packages/BarometryKit/Sources/BarometryKit/Model/SensorSample.swift @@ -56,22 +56,20 @@ public struct GPUSample: Equatable, Sendable { /// Average clock speed while active, over the last interval. Nil when the unit was idle /// for the whole interval. public struct FrequencySample: Equatable, Sendable { - public let efficiencyCores: Frequency? - public let performanceCores: Frequency? + public let cores: [CoreKind: Frequency] public let gpu: Frequency? /// Highest clock in each table, for scaling gauges. public let gpuMaximum: Frequency? - public init(efficiencyCores: Frequency?, performanceCores: Frequency?, gpu: Frequency?, gpuMaximum: Frequency?) { - self.efficiencyCores = efficiencyCores - self.performanceCores = performanceCores + public init(cores: [CoreKind: Frequency], gpu: Frequency?, gpuMaximum: Frequency?) { + self.cores = cores self.gpu = gpu self.gpuMaximum = gpuMaximum } - /// The headline CPU clock: performance cores when they ran, otherwise efficiency cores. + /// The headline CPU clock: the fastest core kind that ran. public var cpu: Frequency? { - performanceCores ?? efficiencyCores + CoreKind.allCases.reversed().lazy.compactMap { cores[$0] }.first } } @@ -94,6 +92,11 @@ enum DVFS { return Frequency(hertz: weighted / total) } + static func voltageStateIndices(fromAccClusters data: [UInt8]) -> [Int: Int] { + let entries = stride(from: 0, to: data.count - 7, by: 8).map { (cluster: Int(data[$0 + 1]), table: Int(data[$0])) } + return Dictionary(entries.map { ($0.cluster, $0.table) }) { first, _ in first } + } + /// Frequencies from a device tree `voltage-states` property: little-endian /// (frequency, voltage) UInt32 pairs. Zero-frequency (off) entries are dropped. /// Units vary by chip generation, so values are normalized to hertz by magnitude. diff --git a/Packages/BarometryKit/Sources/BarometryKit/Samplers/FrequencySampler.swift b/Packages/BarometryKit/Sources/BarometryKit/Samplers/FrequencySampler.swift index 3602afb..9605492 100644 --- a/Packages/BarometryKit/Sources/BarometryKit/Samplers/FrequencySampler.swift +++ b/Packages/BarometryKit/Sources/BarometryKit/Samplers/FrequencySampler.swift @@ -11,23 +11,52 @@ struct FrequencySampler { ("CPU Stats", "CPU Complex Performance States"), ("GPU Stats", "GPU Performance States"), ]) - private let efficiencyTable: [Frequency] - private let performanceTable: [Frequency] + private struct CoreCluster { + let kind: CoreKind + let channelPrefix: String + let table: [Frequency] + } + + private static let legacyCoreTableKeys: [Character: String] = ["E": "voltage-states1-sram", "P": "voltage-states5-sram"] + + private let coreClusters: [CoreCluster] private let gpuTable: [Frequency] init() { - let tables = Self.voltageStateTables(["voltage-states1-sram", "voltage-states5-sram", "voltage-states9"]) - efficiencyTable = tables[0] - performanceTable = tables[1] - gpuTable = tables[2] + let pmgr = IOServiceGetMatchingService(kIOMainPortDefault, IOServiceNameMatching("pmgr")) + defer { IOObjectRelease(pmgr) } + func data(_ key: String) -> [UInt8]? { + guard pmgr != IO_OBJECT_NULL, + let value = IORegistryEntryCreateCFProperty(pmgr, key as CFString, kCFAllocatorDefault, 0)?.takeRetainedValue() as? Data + else { return nil } + return Array(value) + } + func table(_ key: String) -> [Frequency] { + data(key).map(DVFS.frequencyTable(fromVoltageStates:)) ?? [] + } + + let clusters = CoreTopology.current().clusters + let kindByType = clusters.isEmpty + ? ["E": .efficiency, "P": .performance] + : Dictionary(clusters.map { ($0.type, $0.kind) }) { first, _ in first } + let voltageStatesByCluster = data("acc-clusters").map(DVFS.voltageStateIndices(fromAccClusters:)) ?? [:] + + coreClusters = kindByType.sorted { $0.key < $1.key }.map { type, kind in + let legacyTable = Self.legacyCoreTableKeys[type].map(table) ?? [] + let discoveredTable = clusters.first { $0.type == type } + .flatMap { voltageStatesByCluster[$0.id] } + .map { table("voltage-states\($0)-sram") } ?? [] + return CoreCluster(kind: kind, channelPrefix: "\(type)CPU", table: legacyTable.isEmpty ? discoveredTable : legacyTable) + } + gpuTable = table("voltage-states9") } /// Nil on the first call and when IOReport is unavailable. func sample() -> FrequencySample? { guard let channels = subscription?.sample(), !channels.isEmpty else { return nil } - // Channel names: ECPU/PCPU per cluster (with a trailing number on multi-cluster chips), - // ECPM/PCPM for cluster memory, which is skipped, and GPUPH for the GPU. + // Channel names: ECPU/MCPU/PCPU per cluster (with a trailing number on multi-cluster chips), + // ECPM/MCPM/PCPM for cluster memory, which is skipped, and GPUPH for the GPU. func frequency(prefix: String, table: [Frequency]) -> Frequency? { let states = channels .filter { $0.name.hasPrefix(prefix) } @@ -35,9 +64,11 @@ struct FrequencySampler { return DVFS.averageFrequency(states: Self.mergeByName(states), table: table) } + let cores = coreClusters.compactMap { cluster in + frequency(prefix: cluster.channelPrefix, table: cluster.table).map { (cluster.kind, $0) } + } return FrequencySample( - efficiencyCores: frequency(prefix: "ECPU", table: efficiencyTable), - performanceCores: frequency(prefix: "PCPU", table: performanceTable), + cores: Dictionary(cores) { first, _ in first }, gpu: frequency(prefix: "GPUPH", table: gpuTable), gpuMaximum: gpuTable.max() ) @@ -56,13 +87,4 @@ struct FrequencySampler { return order.map { ($0, totals[$0] ?? 0) } } - private static func voltageStateTables(_ keys: [String]) -> [[Frequency]] { - let pmgr = IOServiceGetMatchingService(kIOMainPortDefault, IOServiceNameMatching("pmgr")) - guard pmgr != IO_OBJECT_NULL else { return keys.map { _ in [] } } - defer { IOObjectRelease(pmgr) } - return keys.map { key in - guard let data = IORegistryEntryCreateCFProperty(pmgr, key as CFString, kCFAllocatorDefault, 0)?.takeRetainedValue() as? Data else { return [] } - return DVFS.frequencyTable(fromVoltageStates: Array(data)) - } - } } diff --git a/Packages/BarometryKit/Tests/BarometryKitTests/SensorTests.swift b/Packages/BarometryKit/Tests/BarometryKitTests/SensorTests.swift index 7138618..eef68ca 100644 --- a/Packages/BarometryKit/Tests/BarometryKitTests/SensorTests.swift +++ b/Packages/BarometryKit/Tests/BarometryKitTests/SensorTests.swift @@ -48,6 +48,22 @@ struct SensorTests { #expect(table == [Frequency(megahertz: 744), Frequency(megahertz: 2748)]) } + @Test func accClustersMapClusterIDsToVoltageStateTables() { + let m5Max: [UInt8] = [0x16, 0, 0, 0, 0, 0, 0, 0, 0x17, 1, 0, 0, 0, 0, 0, 0, 0x05, 2, 0, 0, 0, 0, 0, 0] + + #expect(DVFS.voltageStateIndices(fromAccClusters: m5Max) == [0: 22, 1: 23, 2: 5]) + } + + @Test func headlineCPUFrequencyIsTheFastestKindThatRan() { + let frequencies = FrequencySample( + cores: [.performance: Frequency(megahertz: 1344), .super: Frequency(megahertz: 4608)], + gpu: nil, + gpuMaximum: nil + ) + + #expect(frequencies.cpu == Frequency(megahertz: 4608)) + } + @Test func decodesSMCDataTypes() { let float = Float(43.5).bitPattern let floatBytes = (0..<4).map { UInt8(truncatingIfNeeded: float >> ($0 * 8)) }