Add support for SST-CP features (#260)

* Add support for SST-CP features

Author: pbrownlow7

intel/init.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from . import config, topology, discover, sst_bf as sst
+from . import config, topology, discover, sst_bf as sst, sst_cp as cp
 import logging
 import sys
 
@@ -39,14 +39,88 @@ def init(conf_dir, num_exclusive_cores, num_shared_cores,
         logging.info("Could not read SST-BF label from the node metadata: {}"
                      .format(err))
 
+    sst_cp = False
+    try:
+        sst_cp = discover.get_node_label(cp.NFD_LABEL) in ["true", "True"]
+    except Exception as err:
+        logging.info("Could not read SST-CP label from the node metadata: {}"
+                     .format(err))
+
+    if sst_bf and sst_cp:
+        logging.error("SST-BF and SST-CP are mutually exclusive features in "
+                      "CMK, please disable one or both.")
+        sys.exit(1)
+
     platform = topology.discover(sst_bf)
 
     # List of intel.topology.Core objects.
     cores = platform.get_cores()
 
     check_isolated_cores(platform, num_exclusive_cores, num_shared_cores)
 
-    if sst_bf and platform.has_isolated_sst_bf_cores():
+    if sst_cp and platform.has_isolated_cores():
+        epp_order = cp.get_epp_order(platform)
+
+        if len(epp_order) > 3:
+            logging.error("There must not be more than 3 EPP values "
+                          "among the cores. EPP values present: {}"
+                          .format(", ".join(epp_order)))
+            sys.exit(1)
+
+        check_sst_cp_isolated_cores(platform, num_exclusive_cores,
+                                    num_shared_cores, epp_order)
+        logging.info("EPP order: {}".format(", ".join(epp_order)))
+
+        if len(epp_order) == 3:
+            sst_cp_exclusive_cores = platform.get_epp_cores(
+                 epp_order[0], num_exclusive_cores)
+            sst_cp_shared_cores = platform.get_epp_cores(
+                 epp_order[1], num_shared_cores)
+            sst_cp_infra_cores = platform.get_epp_cores_no_limit(
+                 epp_order[2])
+
+            logging.info("Isolated SST-CP exclusive cores (EPP value:"
+                         " {}): {}".format(epp_order[0], ",".join(
+                          [str(c.core_id) for c in sst_cp_exclusive_cores])))
+            logging.info("Isolated SST-CP shared cores (EPP value: {}"
+                         "): {}".format(epp_order[1], ",".join(
+                          [str(c.core_id) for c in sst_cp_shared_cores])))
+            logging.info("SST-CP infra cores (EPP value: {}): {}"
+                         .format(epp_order[2], ",".join([str(c.core_id)
+                                 for c in sst_cp_infra_cores])))
+        elif len(epp_order) == 2:
+            logging.info("Only two EPP values set; exclusive and "
+                         "shared pools will take all of the cores "
+                         "of the highest EPP value")
+            sst_cp_exclusive_cores = platform.get_epp_cores(
+                 epp_order[0], num_exclusive_cores)
+            sst_cp_shared_cores = platform.get_epp_cores(
+                 epp_order[0], num_shared_cores, sst_cp_exclusive_cores)
+            sst_cp_infra_cores = platform.get_epp_cores_no_limit(
+                 epp_order[1])
+
+            logging.info("Isolated SST-CP exclusive cores (EPP value: {}): {}"
+                         .format(epp_order[0], ",".join([str(c.core_id)
+                                 for c in sst_cp_exclusive_cores])))
+            logging.info("Isolated SST-CP shared cores (EPP value: {}): {}"
+                         .format(epp_order[0], ",".join([str(c.core_id)
+                                 for c in sst_cp_shared_cores])))
+            logging.info("SST-CP infra cores (EPP value {}): {}"
+                         .format(epp_order[1], ",".join([str(c.core_id)
+                                 for c in sst_cp_infra_cores])))
+        else:
+            logging.error("There must be either 2 or 3 EPP values set among "
+                          "the cores. EPP values present: {}".format(
+                              ", ".join(epp_order)))
+            sys.exit(1)
+
+        assign(sst_cp_exclusive_cores, "exclusive",
+               count=num_exclusive_cores)
+        assign(sst_cp_shared_cores, "shared",
+               count=num_shared_cores)
+        assign(sst_cp_infra_cores, "infra")
+
+    elif sst_bf and platform.has_isolated_sst_bf_cores():
         sst_bf_cores = [str(c.core_id) for c
                         in platform.get_isolated_sst_bf_cores()]
         logging.info("Isolated SST-BF physical cores: {}".format(
@@ -172,6 +246,44 @@ def check_isolated_cores(platform, num_exclusive_cores, num_shared_cores):
                 (num_isolated_cores, required_isolated_cores))
 
 
+def check_sst_cp_isolated_cores(platform, num_exclusive_cores,
+                                num_shared_cores, epp_order):
+    error_occured = False
+
+    if len(epp_order) == 3:
+        exclusive_cores = platform.get_epp_cores_no_limit(epp_order[0])
+        shared_cores = platform.get_epp_cores_no_limit(epp_order[1])
+
+        if num_exclusive_cores != len(exclusive_cores):
+            logging.error("Number of requested exclusive cores must"
+                          " match the number of cores with EPP value"
+                          " %s. Exclusive cores %d compared to requested %d"
+                          % (epp_order[0], len(exclusive_cores),
+                             num_exclusive_cores))
+            error_occured = True
+
+        if num_shared_cores != len(shared_cores):
+            logging.error("Number of requested shared cores must"
+                          " match the number of cores with EPP value"
+                          " %s. Shared cores %d compared to requested %d"
+                          % (epp_order[1], len(shared_cores),
+                             num_shared_cores))
+            error_occured = True
+    elif len(epp_order) == 2:
+        requested_cores = num_exclusive_cores + num_shared_cores
+        cores = platform.get_epp_cores_no_limit(epp_order[0])
+
+        if len(cores) != requested_cores:
+            logging.error("Requested number of isolated cores "
+                          "should match number of cores with EPP "
+                          "value %s. %d cores requested. %d cores available",
+                          epp_order[0], requested_cores, len(cores))
+            error_occured = True
+
+    if error_occured:
+        sys.exit(1)
+
+
 def assign(cores, pool, count=None):
     free_cores = [c for c in cores if c.pool is None]
 

intel/sst_cp.py

@@ -0,0 +1,47 @@
+CPU_EPP_PATH = "/sys/devices/system/cpu/cpu{}/cpufreq\
+/energy_performance_preference"
+
+NFD_LABEL = "feature.node.kubernetes.io/cpu-power.sst_cp.enabled"
+
+
+def get_epp_order(platform):
+    epp_order = ["performance", "balance_performance",
+                 "balance_power", "power"]
+    epp_values_present = []
+    current_epp_conf = []
+
+    for c in platform.get_cores():
+        with open(CPU_EPP_PATH.format(c.core_id)) as f:
+            core_epp_value = f.read().split("\n")[0]
+            if core_epp_value not in epp_values_present:
+                epp_values_present.append(core_epp_value)
+
+    for epp_value in epp_order:
+        if epp_value in epp_values_present:
+            current_epp_conf.append(epp_value)
+
+    return current_epp_conf
+
+
+def get_epp_cores(platform, epp_value, num_required, unavailable_cores):
+    cores = []
+    unavailable_core_ids = [c.core_id for c in unavailable_cores]
+    for socket in platform.sockets.values():
+        for core_id in socket.cores.keys():
+            if core_id not in unavailable_core_ids:
+                with open(CPU_EPP_PATH.format(core_id)) as f:
+                    if f.readline().rstrip() == epp_value:
+                        cores.append(socket.cores[core_id])
+                        if len(cores) == num_required:
+                            return cores
+
+
+def get_epp_cores_no_limit(platform, epp_value):
+    cores = []
+    for socket in platform.sockets.values():
+        for core_id in socket.cores.keys():
+            with open(CPU_EPP_PATH.format(core_id)) as f:
+                if f.readline().rstrip() == epp_value:
+                    cores.append(socket.cores[core_id])
+
+    return cores

intel/topology.py

@@ -19,6 +19,7 @@
 import os
 import subprocess
 from . import sst_bf
+from . import sst_cp
 
 ENV_LSCPU_SYSFS = "CMK_DEV_LSCPU_SYSFS"
 
@@ -138,6 +139,14 @@ def get_cores_from_pool(self, pool):
             cores += socket.get_cores_from_pool(pool)
         return cores
 
+    def get_epp_cores(self, epp_value, num_required,
+                      unavailable_cores=[]):
+        return sst_cp.get_epp_cores(self, epp_value, num_required,
+                                    unavailable_cores)
+
+    def get_epp_cores_no_limit(self, epp_value):
+        return sst_cp.get_epp_cores_no_limit(self, epp_value)
+
 
 class Socket:
     def __init__(self, socket_id, cores=None):