Merge branch 'master' of github.com:RRZE-HPC/MachineState

Author: JanLJL

.github/workflows/test-n-publish.yml

@@ -28,8 +28,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        # let's not check MacOS for now (add `macos-latest` later)
-        os: [ubuntu-latest]
+        os: [ubuntu-latest, macos-13, macos-latest]
         python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
     runs-on: ${{ matrix.os }}
 
@@ -45,13 +44,21 @@ jobs:
         sudo apt-get update
         sudo apt-get install slurm slurm-client openmpi-bin clang gfortran clinfo
         sudo apt-get install environment-modules likwid
-    - name: Pre-Install (MacOS)
-      if: startsWith(matrix.os, 'macos')
+    - name: Pre-Install (MacOS x86)
+      if: startsWith(matrix.os, 'macos-13')
       run: |
         brew install slurm open-mpi gcc clinfo modules;
         export PATH="/usr/local/opt/gcc@14/bin":$PATH;
         export CC=gcc-14; export CXX=g++-14;
         export FC=gfortran
+    # do not install clinfo as it is broken for macos-14/15
+    - name: Pre-Install (MacOS Arm64)
+      if: startsWith(matrix.os, 'macos') && !contains(matrix.os, 'macos-13')
+      run: |
+        brew install slurm open-mpi gcc modules;
+        export PATH="/usr/local/opt/gcc@14/bin":$PATH;
+        export CC=gcc-14; export CXX=g++-14;
+        export FC=gfortran
     - name: Pre-Install (generic)
       run: |
         python -m pip install codecov

machinestate.py

@@ -99,6 +99,7 @@
 import re
 import json
 import platform
+import struct
 from subprocess import check_output, DEVNULL
 from glob import glob
 from os.path import join as pjoin
@@ -562,14 +563,20 @@ def match(self, data):
         out = data
         if self.regex is not None:
             regex = re.compile(self.regex)
+            m = None
             for l in NEWLINE_REGEX.split(data):
                 m = regex.match(l)
                 if m:
                     out = m.group(1)
+                    break
                 else:
                     m = regex.search(l)
                     if m:
                         out = m.group(1)
+                        break
+            if not m:
+                out = ""
+                self.parser = None
         return out
     def parse(self, data):
         out = data
@@ -1418,20 +1425,45 @@ def __init__(self, extended=False, anonymous=False):
 class CpuInfoMacOS(InfoGroup):
     def __init__(self, extended=False, anonymous=False):
         super(CpuInfoMacOS, self).__init__(name="CpuInfo", extended=extended, anonymous=anonymous)
-        self.const("MachineType", platform.machine())
-        self.addc("Vendor", "sysctl", "-a", r"machdep.cpu.vendor: (.*)")
-        self.addc("Name", "sysctl", "-a", r"machdep.cpu.brand_string: (.*)")
-        self.addc("Family", "sysctl", "-a", r"machdep.cpu.family: (\d+)", int)
-        self.addc("Model", "sysctl", "-a", r"machdep.cpu.model: (\d+)", int)
-        self.addc("Stepping", "sysctl", "-a", r"machdep.cpu.stepping: (\d+)", int)
-        if extended:
-            self.addc("Flags", "sysctl", "-a", r"machdep.cpu.features: (.*)", tostrlist)
-            self.addc("ExtFlags", "sysctl", "-a", r"machdep.cpu.extfeatures: (.*)", tostrlist)
-            self.addc("Leaf7Flags", "sysctl", "-a", r"machdep.cpu.leaf7_features: (.*)", tostrlist)
-            self.addc("Microcode", "sysctl", "-a", r"machdep.cpu.microcode_version: (.*)")
-            self.addc("ExtFamily", "sysctl", "-a", r"machdep.cpu.extfamily: (\d+)", int)
-            self.addc("ExtModel", "sysctl", "-a", r"machdep.cpu.extmodel: (\d+)", int)
-        self.required(["Vendor", "Family", "Model", "Stepping"])
+        march = platform.machine()
+        self.const("MachineType", march)
+        if march in ["x86_64"]:
+            self.addc("Vendor", "sysctl", "-a", r"machdep.cpu.vendor: (.*)")
+            self.addc("Name", "sysctl", "-a", r"machdep.cpu.brand_string: (.*)")
+            self.addc("Family", "sysctl", "-a", r"machdep.cpu.family: (\d+)", int)
+            self.addc("Model", "sysctl", "-a", r"machdep.cpu.model: (\d+)", int)
+            self.addc("Stepping", "sysctl", "-a", r"machdep.cpu.stepping: (\d+)", int)
+            if extended:
+                self.addc("Flags", "sysctl", "-a", r"machdep.cpu.features: (.*)", tostrlist)
+                self.addc("ExtFlags", "sysctl", "-a", r"machdep.cpu.extfeatures: (.*)", tostrlist)
+                self.addc("Leaf7Flags", "sysctl", "-a", r"machdep.cpu.leaf7_features: (.*)", tostrlist)
+                self.addc("Microcode", "sysctl", "-a", r"machdep.cpu.microcode_version: (.*)")
+                self.addc("ExtFamily", "sysctl", "-a", r"machdep.cpu.extfamily: (\d+)", int)
+                self.addc("ExtModel", "sysctl", "-a", r"machdep.cpu.extmodel: (\d+)", int)
+            self.required(["Vendor", "Family", "Model", "Stepping"])
+        elif march in ["arm64"]:
+            # TODO: Is there a way to get Vendor?
+            self.const("Vendor", "Apple")
+            self.addc("Name", "sysctl", "-a", r"machdep.cpu.brand_string: (.*)")
+            self.addc("Family", "sysctl", "-a", r"hw.cpufamily: (\d+)", int)
+            self.addc("Model", "sysctl", "-a", r"hw.cputype: (\d+)", int)
+            self.addc("Stepping", "sysctl", "-a", r"hw.cpusubtype: (\d+)", int)
+            if extended:
+                self.addc("Flags", "sysctl", "-a hw.optional", parse=CpuInfoMacOS.getflags_arm64)
+            self.required(["Vendor", "Family", "Model", "Stepping"])
+
+    @staticmethod
+    def getflags_arm64(string):
+        outlist = []
+        for line in string.split("\n"):
+            key, value = [
+                    field.split(":") for field in line.split("hw.optional.") if len(field)
+                ][0]
+            if int(value):
+                key = key.replace("arm.", "")
+                outlist.append(key)
+        return outlist
+
 
 class CpuInfo(InfoGroup):
     def __init__(self, extended=False, anonymous=False):
@@ -1670,8 +1702,25 @@ class CpuFrequencyMacOsCpu(InfoGroup):
     def __init__(self, extended=False, anonymous=False):
         super(CpuFrequencyMacOsCpu, self).__init__(extended=extended, anonymous=anonymous)
         self.name = "Cpus"
-        self.addc("MaxFreq", "sysctl", "-a", r"hw.cpufrequency_max: (\d+)", int)
-        self.addc("MinFreq", "sysctl", "-a", r"hw.cpufrequency_min: (\d+)", int)
+        if platform.machine() == "x86_64":
+            self.addc("MaxFreq", "sysctl", "-a", r"hw.cpufrequency_max: (\d+)", int)
+            self.addc("MinFreq", "sysctl", "-a", r"hw.cpufrequency_min: (\d+)", int)
+        elif platform.machine() == "arm64":
+            # AppleSilicon
+            self.addc("Freqs-E-Core", "ioreg", "-k voltage-states1-sram | grep voltage-states1-sram", parse=CpuFrequencyMacOsCpu.get_ioreg_states)
+            self.addc("Freqs-P-Core", "ioreg", "-k voltage-states5-sram | grep voltage-states5-sram", parse=CpuFrequencyMacOsCpu.get_ioreg_states)
+
+    @staticmethod
+    def get_ioreg_states(string):
+        bytestr = re.match(r".*<([0-9A-Fa-f]+)>", string)
+        if bytestr:
+            bytestr = bytestr.group(1)
+            # numbers consecutive in 4-byte little-endian
+            states_int = struct.unpack("<" + int(len(bytestr)/8) * "I", bytes.fromhex(bytestr))
+            # voltage states are in pairs of (freq, voltage)
+            states_int = [x for x in states_int if states_int.index(x)%2 == 0]
+            return states_int
+        return string
 
 class CpuFrequencyMacOsBus(InfoGroup):
     def __init__(self, extended=False, anonymous=False):
@@ -1684,7 +1733,12 @@ class CpuFrequencyMacOs(MultiClassInfoGroup):
     def __init__(self, extended=False, anonymous=False):
         super(CpuFrequencyMacOs, self).__init__(extended=extended, anonymous=anonymous)
         self.name = "CpuFrequency"
-        self.classlist = [CpuFrequencyMacOsCpu, CpuFrequencyMacOsBus]
+        # Apple Silicon with MacOS does not easily print out CPU/BUS freqs, see
+        # https://github.com/giampaolo/psutil/issues/1892
+        if platform.machine() == "x86_64":
+            self.classlist = [CpuFrequencyMacOsCpu, CpuFrequencyMacOsBus]
+        elif platform.machine() == "arm64":
+            self.classlist = [CpuFrequencyMacOsCpu]
         self.classargs = [{} for c in self.classlist]
         self.addc("TimerFreq", "sysctl", "-a", r"hw.tbfrequency: (\d+)", int)
 
@@ -1837,8 +1891,8 @@ def getcpulist(arg):
             ncpus = process_cmd(("sysctl", "-n hw.ncpu", r"(\d+)", int))
             cconfig = process_cmd(("sysctl", "-n hw.cacheconfig", r"([\d\s]+)", tointlist))
             if cconfig and ncpus:
-                if len(cconfig) > int(level):
-                    sharedbycount = int(cconfig[int(level)])
+                sharedbycount = int(cconfig[int(level)])
+                if sharedbycount:
                     for i in range(ncpus//sharedbycount):
                         clist.append(list(range(i*sharedbycount, (i+1)*sharedbycount)))
         return clist
@@ -1848,8 +1902,12 @@ def getcpulist(arg):
 class CacheTopologyMacOS(ListInfoGroup):
     def __init__(self, extended=False, anonymous=False):
         super(CacheTopologyMacOS, self).__init__(anonymous=anonymous, extended=extended)
+        march = platform.machine()
         self.name = "CacheTopology"
-        self.userlist = ["l1i", "l1d", "l2", "l3"]
+        if march in ["x86_64"]:
+            self.userlist = ["l1i", "l1d", "l2", "l3"]
+        elif march in ["arm64"]:
+            self.userlist = ["l1i", "l1d", "l2"]
         self.subclass = CacheTopologyMacOSClass
 
 
@@ -3356,6 +3414,8 @@ def __init__(self, platform, extended=False, anonymous=False, clinfo_path=""):
             self.addc("Vendor", clcmd, cmdopts, r"\s+CL_PLATFORM_VENDOR\s+(.+)", str)
             #self.commands["IcdSuffix"] = (clcmd, cmdopts, r"\s+CL_PLATFORM_ICD_SUFFIX_KHR\s+(.+)", str)
             suffix = process_cmd((clcmd, cmdopts, r"\s+CL_PLATFORM_ICD_SUFFIX_KHR\s+(.+)", str))
+            if " " in suffix:
+                suffix = "P0"
             self.const("IcdSuffix", suffix)
             num_devs = process_cmd((clcmd, cmdopts, r".*{}.*#DEVICES\s*(\d+)".format(suffix), int))
             if num_devs and num_devs > 0: