Rqd reserve all cores

rqd/rqd/rqmachine.py

@@ -860,7 +860,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():
@@ -869,14 +869,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)
 
@@ -888,18 +888,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), key=int)
+            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))