coresched.py

   1 # $Id$
   2 # $URL$
   3
   4 """Whole core scheduling
   5
   6 """
   7
   8 import logger
   9 import os
  10
  11 class CoreSched:
  12     """ Whole-core scheduler
  13
  14         The main entrypoint is adjustCores(self, slivers) which takes a
  15         dictionary of sliver records. The cpu_cores field is pulled from the
  16         effective rspec (rec["_rspec"]) for each sliver.
  17
  18         If cpu_cores > 0 for a sliver, then that sliver will reserve one or
  19         more of the cpu_cores on the machine.
  20
  21         One core is always left unreserved for system slices.
  22     """
  23
  24     def __init__(self):
  25         self.cpus = []
  26
  27     def get_cpus(self):
  28         """ return a list of available cpu identifiers: [0,1,2,3...]
  29         """
  30
  31         # the cpus never change, so if it's already been computed then don't
  32         # worry about it.
  33         if self.cpus!=[]:
  34             return self.cpus
  35
  36         cpuset_cpus = open("/dev/cgroup/cpuset.cpus").readline().strip()
  37
  38         # cpuset.cpus could be something as arbitrary as:
  39         #    0,1,2-3,4,5-6
  40         # deal with commas and ranges
  41         for part in cpuset_cpus.split(","):
  42             cpuRange = part.split("-")
  43             if len(cpuRange) == 1:
  44                 cpuRange = (cpuRange[0], cpuRange[0])
  45             for i in range(int(cpuRange[0]), int(cpuRange[1])+1):
  46                 if not i in self.cpus:
  47                     self.cpus.append(i)
  48
  49             return self.cpus
  50
  51     def get_cgroups (self):
  52         """ return a list of cgroups
  53             this might change as vservers are instantiated, so always compute
  54             it dynamically.
  55         """
  56         cgroups = []
  57         filenames = os.listdir("/dev/cgroup")
  58         for filename in filenames:
  59             if os.path.isdir(os.path.join("/dev/cgroup", filename)):
  60                 cgroups.append(filename)
  61         return cgroups
  62
  63     def adjustCores (self, slivers):
  64         """ slivers is a dict of {sliver_name: rec}
  65                 rec is a dict of attributes
  66                     rec['_rspec'] is the effective rspec
  67         """
  68
  69         logger.log("CoreSched: adjusting cores")
  70
  71         cpus = self.get_cpus()[:]
  72
  73         reservations = {}
  74
  75         for name, rec in slivers.iteritems():
  76             rspec = rec["_rspec"]
  77             cores = rspec.get("cpu_cores", 0)
  78             while (cores>0):
  79                 # one cpu core reserved for best effort and system slices
  80                 if len(cpus)<=1:
  81                     logger.log("CoreSched: ran out of cpu cores while scheduling: " + name)
  82                 else:
  83                     cpu = cpus.pop()
  84                     logger.log("CoreSched: allocating cpu " + str(cpu) + " to slice " + name)
  85                     reservations[name] = reservations.get(name,[]) + [cpu]
  86
  87                 cores = cores-1
  88
  89         # the leftovers go to everyone else
  90         logger.log("CoreSched: allocating cpus " + str(cpus) + " to _default")
  91         reservations["_default"] = cpus[:]
  92
  93         self.reserveCores(reservations)
  94
  95     def reserveCores (self, reservations):
  96         """ give a set of reservations (dictionary of slicename:cpuid_list),
  97             write those reservations to the appropriate cgroup files.
  98
  99             reservations["_default"] is assumed to be the default reservation
 100             for slices that do not reserve cores. It's essentially the leftover
 101             cpu cores.
 102         """
 103
 104         default = reservations["_default"]
 105
 106         # set the default vserver cpuset. this will deal with any vservers
 107         # that might be created before the nodemanager has had a chance to
 108         # update the cpusets.
 109         self.reserveDefault(default)
 110
 111         for cgroup in self.get_cgroups():
 112             cpus = reservations.get(cgroup, default)
 113
 114             logger.log("CoreSched: reserving " + cgroup + " " + str(cpus))
 115
 116             file("/dev/cgroup/" + cgroup + "/cpuset.cpus", "w").write( self.listToRange(cpus) + "\n" )
 117
 118     def reserveDefault (self, cpus):
 119         if not os.path.exists("/etc/vservers/.defaults/cgroup"):
 120             os.makedirs("/etc/vservers/.defaults/cgroup")
 121
 122         file("/etc/vservers/.defaults/cgroup/cpuset.cpus", "w").write( self.listToRange(cpus) + "\n" )
 123
 124     def listToRange (self, list):
 125         """ take a list of items [1,2,3,5,...] and return it as a range: "1-3,5"
 126             for now, just comma-separate
 127         """
 128         return ",".join( [str(i) for i in list] )
 129
 130 # a little self-test
 131 if __name__=="__main__":
 132     x = CoreSched()
 133
 134     print "cpus:", x.listToRange(x.get_cpus())
 135     print "cgroups:", ",".join(x.get_cgroups())
 136
 137     # a quick self-test for ScottLab slices sl_test1 and sl_test2
 138     #    sl_test1 = 1 core
 139     #    sl_test2 = 1 core
 140
 141     rspec_sl_test1 = {"cpu_cores": 1}
 142     rec_sl_test1 = {"_rspec": rspec_sl_test1}
 143
 144     rspec_sl_test2 = {"cpu_cores": 1}
 145     rec_sl_test2 = {"_rspec": rspec_sl_test2}
 146
 147     slivers = {"sl_test1": rec_sl_test1, "sl_test2": rec_sl_test2}
 148
 149     x.adjustCores(slivers)
 150