Added the “IRQ Lanes” and “Class” columns

Author: spddl

app.go

@@ -268,6 +268,10 @@ func main() {
 						Name:  "FriendlyName",
 						Title: "Friendly Name",
 					},
+
+					{
+						Name: "Class",
+					},
 					{
 						Name:  "LocationInformation",
 						Title: "Location Info",
@@ -389,6 +393,15 @@ func main() {
 							}
 						},
 					},
+
+					{
+						Name:  "IRQLanes",
+						Title: "IRQ Lanes",
+						FormatFunc: func(value any) string {
+							return strings.Join(value.([]string), ", ")
+						},
+					},
+
 					{
 						Name:  "DevObjName",
 						Title: "DevObj Name",

cpusetinformation.go

@@ -1,9 +1,8 @@
 package main
 
 import (
-	"log"
-
-	"golang.org/x/sys/windows"
+	"fmt"
+	"sort"
 )
 
 var SystemCpuSets = []SYSTEM_CPU_SET_INFORMATION{}
@@ -14,20 +13,15 @@ const (
 	ToolTipTextEfficiencyClass = "A value indicating the intrinsic energy efficiency of a processor for systems that support heterogeneous processors (such as ARM big.LITTLE systems). CPU Sets with higher numerical values of this field have home processors that are faster but less power-efficient than ones with lower values."
 )
 
-type CoreLayout struct {
-	Rows int
-	Cols int
-}
-
 type CpuSets struct {
-	HyperThreading    bool
-	CoreCount         int
 	MaxThreadsPerCore int
+	CPU               []CpuSet
+	CoreGroups        []CoreGroups
+	CoreLayout        *CoreLayout
+	HyperThreading    bool
 	NumaNode          bool // A group-relative value indicating which NUMA node a CPU Set is on. All CPU Sets in a given group that are on the same NUMA node will have the same value for this field.
 	LastLevelCache    bool // A group-relative value indicating which CPU Sets share at least one level of cache with each other. This value is the same for all CPU Sets in a group that are on processors that share cache with each other.
 	EfficiencyClass   bool // A value indicating the intrinsic energy efficiency of a processor for systems that support heterogeneous processors (such as ARM big.LITTLE systems). CPU Sets with higher numerical values of this field have home processors that are faster but less power-efficient than ones with lower values.
-	CPU               []CpuSet
-	Layout            []CoreLayout
 }
 
 type CpuSet struct {
@@ -39,38 +33,66 @@ type CpuSet struct {
 	NumaNodeIndex         byte // A group-relative value indicating which NUMA node a CPU Set is on. All CPU Sets in a given group that are on the same NUMA node will have the same value for this field.
 }
 
-func (cs *CpuSets) Init() {
-	var SystemCpuSets = make([]SYSTEM_CPU_SET_INFORMATION, 1)
-	var length uint32
-	var hProcess windows.Handle
+type CoreGroups struct {
+	Rows int
+	Cols int
+}
+
+type CoreLayout struct {
+	Numa []NumaItem
+}
 
-	GetSystemCpuSetInformation(&SystemCpuSets[0], 1, &length, uintptr(hProcess), 0)
+type NumaItem struct {
+	Ccd []CcdItem
+}
+
+type CcdItem struct {
+	Eff EffFields
+}
 
-	SystemCpuSets = make([]SYSTEM_CPU_SET_INFORMATION, length)
-	success := GetSystemCpuSetInformation(&SystemCpuSets[0], uint32(length), &length, uintptr(hProcess), 0)
-	if success != 1 {
-		log.Println("err")
+type EffFields struct {
+	Nums map[int][][]int
+}
+
+func (item *EffFields) isNil() bool {
+	if item.Nums == nil {
+		return true
 	}
+	return false
+}
 
-	/// debug
-	// Fake13900()
-	// Fake13900WithoutHT()
-	// Fake5900x()
-	// Fake8Threads()
-	// FakeNumaCCD12Core()
-	// Fake2CCD12CoreHT()
-	// Fake13600KF()
+func (item *CoreLayout) add(numa, ccd, effClass, core, thread int) {
+	if len(item.Numa) <= numa {
+		item.Numa = append(item.Numa, make([]NumaItem, numa+1-len(item.Numa))...)
+	}
+
+	if len(item.Numa[numa].Ccd) <= ccd {
+		item.Numa[numa].Ccd = append(item.Numa[numa].Ccd, make([]CcdItem, ccd+1-len(item.Numa[numa].Ccd))...)
+	}
+
+	if item.Numa[numa].Ccd[ccd].Eff.Nums == nil {
+		item.Numa[numa].Ccd[ccd].Eff.Nums = make(map[int][][]int)
+	}
+	rows := item.Numa[numa].Ccd[ccd].Eff.Nums[effClass]
+
+	if len(rows) <= core {
+		rows = append(rows, make([][]int, core+1-len(rows))...)
+	}
+
+	rows[core] = append(rows[core], thread)
+
+	item.Numa[numa].Ccd[ccd].Eff.Nums[effClass] = rows
+}
+
+func (cs *CpuSets) Init() {
+	SystemCpuSets = GetCpuInformation()
+
+	cs.CoreLayout = new(CoreLayout)
 
-	cs.CoreCount = int(uint32(len(SystemCpuSets)) / SystemCpuSets[0].Size)
-	var lastEfficiencyClass, lastLevelCache, lastNumaNodeIndex byte
-	var LogicalCores int
 	var ClassGroup = []int{}
-	for i := 0; i < cs.CoreCount; i++ {
+	var lastEfficiencyClass, lastLevelCache, lastNumaNodeIndex byte
+	for i := 0; i < int(uint32(len(SystemCpuSets))/SystemCpuSets[0].Size); i++ {
 		cpu := SystemCpuSets[i].CpuSet()
-		if i == 0 { // The EfficiencyClass starts with 1 on the Intel Gen12+
-			lastEfficiencyClass = cpu.EfficiencyClass
-		}
-
 		cs.CPU = append(cs.CPU, CpuSet{
 			Id:                    cpu.Id,
 			CoreIndex:             cpu.CoreIndex,
@@ -80,22 +102,21 @@ func (cs *CpuSets) Init() {
 			NumaNodeIndex:         cpu.NumaNodeIndex,
 		})
 
-		// fmt.Printf("(%02d) [%d/%x] %02d/%02d Eff%d CCD%d NUMA%d\n", i, cpu.Id, cpu.Id, cpu.CoreIndex, cpu.LogicalProcessorIndex, cpu.EfficiencyClass, cpu.LastLevelCacheIndex, cpu.NumaNodeIndex)
-
-		if cpu.CoreIndex != cpu.LogicalProcessorIndex {
-			if !cs.HyperThreading {
-				cs.HyperThreading = true
-			}
-			if cs.MaxThreadsPerCore < int(cpu.LogicalProcessorIndex-cpu.CoreIndex) {
-				cs.MaxThreadsPerCore = int(cpu.LogicalProcessorIndex - cpu.CoreIndex)
-			}
-		} else {
-			LogicalCores++
-
-			for len(ClassGroup) <= int(cpu.EfficiencyClass) {
-				ClassGroup = append(ClassGroup, 0)
-			}
-			ClassGroup[int(cpu.EfficiencyClass)]++
+		fmt.Printf("(%02d) [%d/%x] %02d/%02d Eff%d CCD%d NUMA%d\n", i, cpu.Id, cpu.Id, cpu.CoreIndex, cpu.LogicalProcessorIndex, cpu.EfficiencyClass, cpu.LastLevelCacheIndex, cpu.NumaNodeIndex)
+
+		cs.CoreLayout.add(int(cpu.NumaNodeIndex), int(cpu.LastLevelCacheIndex), int(cpu.EfficiencyClass), int(cpu.CoreIndex), int(cpu.LogicalProcessorIndex))
+
+		if cs.MaxThreadsPerCore < int(cpu.LogicalProcessorIndex-cpu.CoreIndex) {
+			cs.MaxThreadsPerCore = int(cpu.LogicalProcessorIndex-cpu.CoreIndex) + 1
+		}
+
+		for len(ClassGroup) <= int(cpu.EfficiencyClass) {
+			ClassGroup = append(ClassGroup, 0)
+		}
+		ClassGroup[int(cpu.EfficiencyClass)]++
+
+		if !cs.HyperThreading && cpu.CoreIndex != cpu.LogicalProcessorIndex {
+			cs.HyperThreading = true
 		}
 
 		if !cs.EfficiencyClass && lastEfficiencyClass != cpu.EfficiencyClass {
@@ -109,17 +130,20 @@ func (cs *CpuSets) Init() {
 		if !cs.NumaNode && lastNumaNodeIndex != cpu.NumaNodeIndex {
 			cs.NumaNode = true
 		}
-
-		lastEfficiencyClass = cpu.EfficiencyClass
-		lastLevelCache = cpu.LastLevelCacheIndex
-		lastNumaNodeIndex = cpu.NumaNodeIndex
 	}
 
+	sort.Slice(cs.CPU, func(i, j int) bool {
+		if cs.CPU[i].EfficiencyClass != cs.CPU[j].EfficiencyClass {
+			return cs.CPU[i].EfficiencyClass < cs.CPU[j].EfficiencyClass
+		}
+		if cs.CPU[i].CoreIndex != cs.CPU[j].CoreIndex {
+			return cs.CPU[i].CoreIndex < cs.CPU[j].CoreIndex
+		}
+		return cs.CPU[i].LogicalProcessorIndex < cs.CPU[j].LogicalProcessorIndex
+	})
+
 	rows, cols := getLayout(ClassGroup...)
 	for _, col := range cols {
-		cs.Layout = append(cs.Layout, CoreLayout{
-			Rows: rows,
-			Cols: col,
-		})
+		cs.CoreGroups = append(cs.CoreGroups, CoreGroups{Rows: rows, Cols: col})
 	}
 }