Standardize object names

Author: ben-grande

qubes/qmemman/algo.py

@@ -20,11 +20,14 @@
 
 import logging
 
-# This are only defaults - can be overridden by QMemmanServer with values from
-# config file
+# These defaults can be overridden by QMemmanServer with values from config
+# file.
 CACHE_FACTOR = 1.3
 MIN_PREFMEM = 200 * 1024 * 1024
 DOM0_MEM_BOOST = 350 * 1024 * 1024
+# REQ_SAFETY_NET_FACTOR is a bit greater that 1. So that if the domain
+# yields a bit less than requested, due to e.g. rounding errors, we will not
+# get stuck. The surplus will return to the VM during "balance" call.
 REQ_SAFETY_NET_FACTOR = 1.05
 
 log = logging.getLogger("qmemman.daemon.algo")
@@ -40,188 +43,179 @@ def sanitize_and_parse_meminfo(untrusted_meminfo):
     return int(untrusted_meminfo) * 1024
 
 
-# Called when a domain updates its 'meminfo' xenstore key.
 def refresh_meminfo_for_domain(domain, untrusted_xenstore_key):
+    """
+    Called when a domain updates its 'meminfo' xenstore key.
+    """
     domain.mem_used = sanitize_and_parse_meminfo(untrusted_xenstore_key)
 
 
-def prefmem(domain):
+def pref_mem(domain):
     # As dom0 must have large cache for vbds, give it a special boost.
     mem_used = domain.mem_used * CACHE_FACTOR
     if domain.domid == "0":
         mem_used += DOM0_MEM_BOOST
-        return int(min(mem_used, domain.memory_maximum))
-    return int(max(min(mem_used, domain.memory_maximum), MIN_PREFMEM))
+        return int(min(mem_used, domain.mem_max))
+    return int(max(min(mem_used, domain.mem_max), MIN_PREFMEM))
 
 
-def memory_needed(domain):
-    # Do not change. In balance(), "distribute total_available_memory
-    # proportionally to mempref" relies on this exact formula.
-    ret = prefmem(domain) - domain.memory_actual
+def needed_mem(domain):
+    # Do not change. In balance(), "distribute total_available_mem
+    # proportionally to pref_mem" relies on this exact formula.
+    ret = pref_mem(domain) - domain.mem_actual
     return ret
 
 
-# Prepare list of (domain, memory_target) pairs that need to be passed to "xm
-# memset" equivalent in order to obtain "memsize".
+# Prepare list of (domain, mem_target) pairs that need to be passed to "xm
+# memset" equivalent in order to obtain "mem_size".
 # Returns empty list when the request cannot be satisfied.
-def balloon(memsize, domain_dictionary):
+def balloon(mem_size, dom_dict):
     log.debug(
-        "balloon(memsize={!r}, domain_dictionary={!r})".format(
-            memsize, domain_dictionary
-        )
+        "balloon(mem_size={!r}, dom_dict={!r})".format(mem_size, dom_dict)
     )
     donors = []
     request = []
     available = 0
-    for domid, dom in domain_dictionary.items():
+    for domid, dom in dom_dict.items():
         if dom.mem_used is None or dom.no_progress:
             continue
-        need = memory_needed(dom)
+        need = needed_mem(dom)
         if need < 0:
             log.info(
                 "balloon: dom {} has actual memory {}".format(
-                    domid, dom.memory_actual
+                    domid, dom.mem_actual
                 )
             )
             donors.append((domid, -need))
             available -= need
 
-    log.info("req={} avail={} donors={!r}".format(memsize, available, donors))
+    log.info("req={} avail={} donors={!r}".format(mem_size, available, donors))
 
-    if available < memsize:
+    if available < mem_size:
         return []
-    scale = 1.0 * memsize / available
+    scale = 1.0 * mem_size / available
     for donors_iter in donors:
-        dom_id, mem = donors_iter
-        memborrowed = mem * scale * REQ_SAFETY_NET_FACTOR
-        log.info("borrow {} from {}".format(memborrowed, dom_id))
-        memtarget = int(domain_dictionary[dom_id].memory_actual - memborrowed)
-        request.append((dom_id, memtarget))
+        domid, mem = donors_iter
+        mem_borrowed = mem * scale * REQ_SAFETY_NET_FACTOR
+        log.info("borrow {} from {}".format(mem_borrowed, domid))
+        mem_target = int(dom_dict[domid].mem_actual - mem_borrowed)
+        request.append((domid, mem_target))
     return request
 
 
-# REQ_SAFETY_NET_FACTOR is a bit greater that 1. So that if the domain
-# yields a bit less than requested, due to e.g. rounding errors, we will not
-# get stuck. The surplus will return to the VM during "balance" call.
-
-
-# Redistribute positive "total_available_memory" of memory between domains,
-# proportionally to prefmem.
-def balance_when_enough_memory(
-    domain_dictionary, xen_free_memory, total_mem_pref, total_available_memory
+# Redistribute positive "total_available_mem" of memory between domains,
+# proportionally to pref_mem.
+def balance_when_enough_mem(
+    dom_dict, xen_free_mem, total_mem_pref, total_available_mem
 ):
     log.info(
-        "balance_when_enough_memory(xen_free_memory={!r}, "
-        "total_mem_pref={!r}, total_available_memory={!r})".format(
-            xen_free_memory, total_mem_pref, total_available_memory
+        "balance_when_enough_mem(xen_free_mem={!r}, "
+        "total_mem_pref={!r}, total_available_mem={!r})".format(
+            xen_free_mem, total_mem_pref, total_available_mem
         )
     )
 
-    target_memory = {}
+    target_mem = {}
     # Memory not assigned because of static max.
-    left_memory = 0
+    mem_left = 0
     acceptors_count = 0
-    for domid, dom in domain_dictionary.items():
+    for domid, dom in dom_dict.items():
         if dom.mem_used is None or dom.no_progress:
             continue
-        # Distribute total_available_memory proportionally to mempref.
-        scale = 1.0 * prefmem(dom) / total_mem_pref
-        target_nonint = prefmem(dom) + scale * total_available_memory
+        # Distribute total_available_mem proportionally to pref_mem.
+        scale = 1.0 * pref_mem(dom) / total_mem_pref
+        target_nonint = pref_mem(dom) + scale * total_available_mem
         # Prevent rounding errors.
         target = int(0.999 * target_nonint)
         # Do not try to give more memory than static max.
-        if target > dom.memory_maximum:
-            left_memory += target - dom.memory_maximum
-            target = dom.memory_maximum
+        if target > dom.mem_max:
+            mem_left += target - dom.mem_max
+            target = dom.mem_max
         else:
             # Count domains which can accept more memory.
             acceptors_count += 1
-        target_memory[domid] = target
+        target_mem[domid] = target
     # Distribute left memory across all acceptors.
-    while left_memory > 0 and acceptors_count > 0:
+    while mem_left > 0 and acceptors_count > 0:
         log.info(
-            "left_memory={} acceptors_count={}".format(
-                left_memory, acceptors_count
-            )
+            "mem_left={} acceptors_count={}".format(mem_left, acceptors_count)
         )
 
-        new_left_memory = 0
+        new_mem_left = 0
         new_acceptors_count = acceptors_count
-        for domid, target in target_memory.items():
-            dom = domain_dictionary[domid]
-            if target < dom.memory_maximum:
-                memory_bonus = int(0.999 * (left_memory / acceptors_count))
-                if target + memory_bonus >= dom.memory_maximum:
-                    new_left_memory += (
-                        target + memory_bonus - dom.memory_maximum
-                    )
-                    target = dom.memory_maximum
+        for domid, target in target_mem.items():
+            dom = dom_dict[domid]
+            if target < dom.mem_max:
+                mem_bonus = int(0.999 * (mem_left / acceptors_count))
+                if target + mem_bonus >= dom.mem_max:
+                    new_mem_left += target + mem_bonus - dom.mem_max
+                    target = dom.mem_max
                     new_acceptors_count -= 1
                 else:
-                    target += memory_bonus
-            target_memory[domid] = target
-        left_memory = new_left_memory
+                    target += mem_bonus
+            target_mem[domid] = target
+        mem_left = new_mem_left
         acceptors_count = new_acceptors_count
-    # Split target_memory dictionary to donors and acceptors. This is needed to
+    # Split target_mem dictionary to donors and acceptors. This is needed to
     # first get memory from donors and only then give it to acceptors.
     donors_rq = []
     acceptors_rq = []
-    for domid, target in target_memory.items():
-        dom = domain_dictionary[domid]
-        if target < dom.memory_actual:
+    for domid, target in target_mem.items():
+        dom = dom_dict[domid]
+        if target < dom.mem_actual:
             donors_rq.append((domid, target))
         else:
             acceptors_rq.append((domid, target))
     return donors_rq + acceptors_rq
 
 
-# When not enough mem to make everyone be above prefmem, make donors be at
-# prefmem, and redistribute anything left between acceptors.
-def balance_when_low_on_memory(
-    domain_dictionary,
-    xen_free_memory,
+# When not enough mem to make everyone be above pref_mem, make donors be at
+# pref_mem, and redistribute anything left between acceptors.
+def balance_when_low_on_mem(
+    dom_dict,
+    xen_free_mem,
     total_mem_pref_acceptors,
     donors,
     acceptors,
 ):
     log.info(
-        "balance_when_low_on_memory(xen_free_memory={!r}, "
+        "balance_when_low_on_mem(xen_free_mem={!r}, "
         "total_mem_pref_acceptors={!r}, donors={!r}, acceptors={!r})".format(
-            xen_free_memory, total_mem_pref_acceptors, donors, acceptors
+            xen_free_mem, total_mem_pref_acceptors, donors, acceptors
         )
     )
     donors_rq = []
     acceptors_rq = []
-    squeezed_mem = xen_free_memory
+    squeezed_mem = xen_free_mem
     for domid in donors:
-        dom = domain_dictionary[domid]
-        avail = -memory_needed(dom)
+        dom = dom_dict[domid]
+        avail = -needed_mem(dom)
         if avail < 10 * 1024 * 1024:
-            # Probably we have already tried making it exactly at prefmem, give
+            # Probably we have already tried making it exactly at pref_mem, give
             # up.
             continue
         squeezed_mem -= avail
-        donors_rq.append((domid, prefmem(dom)))
+        donors_rq.append((domid, pref_mem(dom)))
     # The below condition can happen if initially xen free memory is below 50M.
     if squeezed_mem < 0:
         return donors_rq
     for domid in acceptors:
-        dom = domain_dictionary[domid]
-        scale = 1.0 * prefmem(dom) / total_mem_pref_acceptors
-        target_nonint = dom.memory_actual + scale * squeezed_mem
+        dom = dom_dict[domid]
+        scale = 1.0 * pref_mem(dom) / total_mem_pref_acceptors
+        target_nonint = dom.mem_actual + scale * squeezed_mem
         # Do not try to give more memory than static max.
-        target = min(int(0.999 * target_nonint), dom.memory_maximum)
+        target = min(int(0.999 * target_nonint), dom.mem_max)
         acceptors_rq.append((domid, target))
     return donors_rq + acceptors_rq
 
 
 # Get memory information.
 # Called before and after domain balances.
 # Return a dictionary of various memory data points.
-def memory_info(xen_free_memory, domain_dictionary):
+def mem_info(xen_free_mem, dom_dict):
     log.debug(
-        "memory_info(xen_free_memory={!r}, domain_dictionary={!r})".format(
-            xen_free_memory, domain_dictionary
+        "mem_info(xen_free_mem={!r}, dom_dict={!r})".format(
+            xen_free_mem, dom_dict
         )
     )
 
@@ -230,7 +224,7 @@ def memory_info(xen_free_memory, domain_dictionary):
     # their preferred memory, and memory that can be taken from domains
     # (donors) that can provide memory. So, it can be negative when plenty of
     # memory.
-    total_memory_needed = 0
+    total_needed_mem = 0
 
     # Sum of memory preferences of all domains.
     total_mem_pref = 0
@@ -241,54 +235,54 @@ def memory_info(xen_free_memory, domain_dictionary):
     donors = []
     acceptors = []
     # Pass 1: compute the above "total" values.
-    for domid, dom in domain_dictionary.items():
+    for domid, dom in dom_dict.items():
         if dom.mem_used is None or dom.no_progress:
             continue
-        need = memory_needed(dom)
-        if need < 0 or dom.memory_actual >= dom.memory_maximum:
+        need = needed_mem(dom)
+        if need < 0 or dom.mem_actual >= dom.mem_max:
             donors.append(domid)
         else:
             acceptors.append(domid)
-            total_mem_pref_acceptors += prefmem(dom)
-        total_memory_needed += need
-        total_mem_pref += prefmem(dom)
+            total_mem_pref_acceptors += pref_mem(dom)
+        total_needed_mem += need
+        total_mem_pref += pref_mem(dom)
 
-    total_available_memory = xen_free_memory - total_memory_needed
+    total_available_mem = xen_free_mem - total_needed_mem
 
-    mem_dictionary = {}
-    mem_dictionary["domain_dictionary"] = domain_dictionary
-    mem_dictionary["total_available_memory"] = total_available_memory
-    mem_dictionary["xen_free_memory"] = xen_free_memory
-    mem_dictionary["total_mem_pref"] = total_mem_pref
-    mem_dictionary["total_mem_pref_acceptors"] = total_mem_pref_acceptors
-    mem_dictionary["donors"] = donors
-    mem_dictionary["acceptors"] = acceptors
-    return mem_dictionary
+    mem_dict = {}
+    mem_dict["dom_dict"] = dom_dict
+    mem_dict["total_available_mem"] = total_available_mem
+    mem_dict["xen_free_mem"] = xen_free_mem
+    mem_dict["total_mem_pref"] = total_mem_pref
+    mem_dict["total_mem_pref_acceptors"] = total_mem_pref_acceptors
+    mem_dict["donors"] = donors
+    mem_dict["acceptors"] = acceptors
+    return mem_dict
 
 
 # Redistribute memory across domains.
 # Called when one of domains update its 'meminfo' xenstore key.
-# Return the list of (domain, memory_target) pairs to be passed to "xm memset"
+# Return the list of (domain, mem_target) pairs to be passed to "xm memset"
 # equivalent
-def balance(xen_free_memory, domain_dictionary):
+def balance(xen_free_mem, dom_dict):
     log.debug(
-        "balance(xen_free_memory={!r}, domain_dictionary={!r})".format(
-            xen_free_memory, domain_dictionary
+        "balance(xen_free_mem={!r}, dom_dict={!r})".format(
+            xen_free_mem, dom_dict
         )
     )
-    memory_dictionary = memory_info(xen_free_memory, domain_dictionary)
-
-    if memory_dictionary["total_available_memory"] > 0:
-        return balance_when_enough_memory(
-            memory_dictionary["domain_dictionary"],
-            memory_dictionary["xen_free_memory"],
-            memory_dictionary["total_mem_pref"],
-            memory_dictionary["total_available_memory"],
+    mem_dict = mem_info(xen_free_mem, dom_dict)
+
+    if mem_dict["total_available_mem"] > 0:
+        return balance_when_enough_mem(
+            mem_dict["dom_dict"],
+            mem_dict["xen_free_mem"],
+            mem_dict["total_mem_pref"],
+            mem_dict["total_available_mem"],
         )
-    return balance_when_low_on_memory(
-        memory_dictionary["domain_dictionary"],
-        memory_dictionary["xen_free_memory"],
-        memory_dictionary["total_mem_pref_acceptors"],
-        memory_dictionary["donors"],
-        memory_dictionary["acceptors"],
+    return balance_when_low_on_mem(
+        mem_dict["dom_dict"],
+        mem_dict["xen_free_mem"],
+        mem_dict["total_mem_pref_acceptors"],
+        mem_dict["donors"],
+        mem_dict["acceptors"],
     )

qubes/qmemman/client.py

@@ -25,7 +25,7 @@ class QMemmanClient:
     def __init__(self):
         self.sock = None
 
-    def request_memory(self, amount):
+    def request_mem(self, amount):
         self.sock = socket.socket(socket.AF_UNIX)
         flags = fcntl.fcntl(self.sock.fileno(), fcntl.F_GETFD)
         flags |= fcntl.FD_CLOEXEC