[PATCH] usertools: enhance CPU layout

[Wenzhuo Lu <wenzhuo.lu@intel.com>]

The cores in a single CPU may be not all
the same.
The user tool is updated to show the
difference of the cores.

This patch addes below informantion,
1, Group the cores based on the die.
2, A core is either a performance core or an
   efficency core.
   A performance core is shown as 'Core-P'.
   An efficency core is shown as 'Core-E'.
3, All the E-cores which share the same L2-cache
   are grouped to one module.

The known limitation.
1, To tell a core is P-core or E-core is based on if
   this core shares L2 cache with others.

Signed-off-by: Wenzhuo Lu <wenzhuo.lu@intel.com>
---
 usertools/cpu_layout.py | 77 +++++++++++++++++++++++++++++++++--------
 1 file changed, 63 insertions(+), 14 deletions(-)

diff --git a/usertools/cpu_layout.py b/usertools/cpu_layout.py
index 891b9238fa..d78758cf2c 100755
--- a/usertools/cpu_layout.py
+++ b/usertools/cpu_layout.py
@@ -1,11 +1,17 @@
 #!/usr/bin/env python3
 # SPDX-License-Identifier: BSD-3-Clause
-# Copyright(c) 2010-2014 Intel Corporation
+# Copyright(c) 2010-2023 Intel Corporation
 # Copyright(c) 2017 Cavium, Inc. All rights reserved.
 
 sockets = []
+dies = []
 cores = []
+module_id = []
 core_map = {}
+core_p_e = {}
+title_len = 47
+die_len = 8
+module_no = 0
 base_path = "/sys/devices/system/cpu"
 fd = open("{}/kernel_max".format(base_path))
 max_cpus = int(fd.read())
@@ -20,19 +26,54 @@
     fd = open("{}/cpu{}/topology/physical_package_id".format(base_path, cpu))
     socket = int(fd.read())
     fd.close()
+    fd = open("{}/cpu{}/topology/die_id".format(base_path, cpu))
+    die = int(fd.read())
+    fd.close()
+    fd = open("{}/cpu{}/topology/thread_siblings_list".format(base_path, cpu))
+    threads_share = str(fd.read())
+    fd.close()
+    fd = open("{}/cpu{}/cache/index2/shared_cpu_list".format(base_path, cpu))
+    l2_cache_share = str(fd.read())
+    fd.close()
+    if (threads_share == l2_cache_share):
+        p_e = '-P'
+        module_id.append(-1)
+    else:
+        module_tmp = []
+        p_e = '-E'
+        for i in l2_cache_share:
+            if not i.isdigit():
+                break
+            module_tmp.append(i)
+        if (cpu == int("".join(module_tmp))):
+            module_id.append(module_no)
+            module_no += 1
+        else:
+            module_id.append(-1)
     if core not in cores:
         cores.append(core)
+    if die not in dies:
+        dies.append(die)
     if socket not in sockets:
         sockets.append(socket)
-    key = (socket, core)
+    key = (socket, die, core)
+    key_p_e = (die, core)
     if key not in core_map:
         core_map[key] = []
+    if key_p_e not in core_p_e:
+        core_p_e[key_p_e] = p_e
     core_map[key].append(cpu)
 
-print(format("=" * (47 + len(base_path))))
+print(format("=" * (title_len + len(base_path))))
 print("Core and Socket Information (as reported by '{}')".format(base_path))
-print("{}\n".format("=" * (47 + len(base_path))))
+print("{}\n".format("=" * (title_len + len(base_path))))
 print("cores = ", cores)
+meaningful_module = []
+for i in module_id:
+    if (i != -1):
+        meaningful_module.append(i)
+print("modules = ", meaningful_module)
+print("dies = ", dies)
 print("sockets = ", sockets)
 print("")
 
@@ -43,22 +84,30 @@
                       + len('[]') + len('Socket ')
 max_core_id_len = len(str(max(cores)))
 
-output = " ".ljust(max_core_id_len + len('Core '))
+socket_space_len = max_core_id_len + len('Core ') + die_len + len('-P')
+output = " ".ljust(socket_space_len)
 for s in sockets:
     output += " Socket %s" % str(s).ljust(max_core_map_len - len('Socket '))
 print(output)
 
-output = " ".ljust(max_core_id_len + len('Core '))
+output = " ".ljust(socket_space_len)
 for s in sockets:
     output += " --------".ljust(max_core_map_len)
     output += " "
 print(output)
 
-for c in cores:
-    output = "Core %s" % str(c).ljust(max_core_id_len)
-    for s in sockets:
-        if (s, c) in core_map:
-            output += " " + str(core_map[(s, c)]).ljust(max_core_map_len)
-        else:
-            output += " " * (max_core_map_len + 1)
-    print(output)
+for d in dies:
+    print("Die", die)
+    for c in cores:
+        if (module_id[core_map[(sockets[0], d, c)][0]] != -1):
+            print("    Module", module_id[core_map[(sockets[0], d, c)][0]])
+        output = " ".ljust(die_len)
+        output += "Core"
+        output += core_p_e[(d, c)]
+        output += " %s" % str(c).ljust(max_core_id_len)
+        for s in sockets:
+            if (s, d, c) in core_map:
+                output += " " + str(core_map[(s, d, c)]).ljust(max_core_map_len)
+            else:
+                output += " " * (max_core_map_len + 1)
+        print(output)
-- 
2.25.1