Rqd reserve all cores

rqd/rqd/rqmachine.py

@@ -279,11 +279,11 @@ def rssUpdate(self, frames):
                     child_statm_fields = self._getStatFields(
                         rqd.rqconstants.PATH_PROC_PID_STATM.format(pid))
                     pids[pid]['statm_size'] = \
-                        int(re.search(r"\d+", child_statm_fields[0]).group()) \
-                        if re.search(r"\d+", child_statm_fields[0]) else -1
+                        int(re.search(r"\d+", child_statm_fields[2]).group()) \
+                        if re.search(r"\d+", child_statm_fields[2]) else -1
                     pids[pid]['statm_rss'] = \
-                        int(re.search(r"\d+", child_statm_fields[1]).group()) \
-                        if re.search(r"\d+", child_statm_fields[1]) else -1
+                        int(re.search(r"\d+", child_statm_fields[3]).group()) \
+                        if re.search(r"\d+", child_statm_fields[3]) else -1
 
                 # pylint: disable=broad-except
                 except (OSError, IOError):
@@ -859,7 +859,7 @@ def reserveHT(self, frameCores):
         # Prefer to assign cores from the same physical cpu.
         # Spread different frames around on different physical cpus.
         avail_cores = {}
-        avail_cores_count = 0
+        avail_procs_count = 0
         reserved_cores = self.__coreInfo.reserved_cores
 
         for physid, cores in self.__procs_by_physid_and_coreid.items():
@@ -868,14 +868,14 @@ def reserveHT(self, frameCores):
                         int(coreid) in reserved_cores[int(physid)].coreid:
                     continue
                 avail_cores.setdefault(physid, set()).add(coreid)
-                avail_cores_count += 1
+                avail_procs_count += len(cores[coreid])
 
-        remaining_cores = frameCores / 100
+        remaining_procs = frameCores / 100
 
-        if avail_cores_count < remaining_cores:
+        if avail_procs_count < remaining_procs:
             err = ('Not launching, insufficient hyperthreading cores to reserve '
                    'based on frameCores (%s < %s)')  \
-                  % (avail_cores_count, remaining_cores)
+                  % (avail_procs_count, remaining_procs)
             log.critical(err)
             raise rqd.rqexceptions.CoreReservationFailureException(err)
 
@@ -887,18 +887,26 @@ def reserveHT(self, frameCores):
                 # the most idle cores first.
                 key=lambda tup: len(tup[1]),
                 reverse=True):
-
-            while remaining_cores > 0 and len(cores) > 0:
-                coreid = cores.pop()
-                # Give all the hyperthreads on this core.
-                # This counts as one core.
+            cores = sorted(list(cores))
+            while remaining_procs > 0 and len(cores) > 0:
+                # Reserve hyper-threaded cores first (2 threads(logical cores) for 1 physical core)
+                # Avoid booking a hyper-threaded core for an odd thread count remainder
+                # ex: if remaining_procs==2, get the next core with 2 threads
+                # ex: if remaining_procs==1, get the next core with 1 thread or any other core
+                # here we fall back on the first physical core
+                # (assuming "first in list" == "has more threads")
+                # if we didn't find a core with the right number of threads, and continue the loop.
+                coreid = next(iter(
+                    [cid for cid in cores
+                     if len(self.__procs_by_physid_and_coreid[physid][cid]) <= remaining_procs]),
+                    cores[0])
+                cores.remove(coreid)
+                procids = self.__procs_by_physid_and_coreid[physid][coreid]
                 reserved_cores[int(physid)].coreid.extend([int(coreid)])
-                remaining_cores -= 1
-
-                for procid in self.__procs_by_physid_and_coreid[physid][coreid]:
-                    tasksets.append(procid)
+                remaining_procs -= len(procids)
+                tasksets.extend(procids)
 
-            if remaining_cores == 0:
+            if remaining_procs == 0:
                 break
 
         log.warning('Taskset: Reserving procs - %s', ','.join(tasksets))