[Xen-changelog] Loop retrying when ballooning out, even when the dom0-min-mem setting means

[Xen patchbot -3.0-testing <patchbot-3.0-testing@xxxxxxxxxxxxxxxxxxx>]

# HG changeset patch
# User emellor@xxxxxxxxxxxxxxxxxxxxxx
# Node ID 809440d54834cd973d95e3033b893ade961d5e07
# Parent  bdaa231489ab19b37d3689d2957fa2c59211374e
Loop retrying when ballooning out, even when the dom0-min-mem setting means
that there is not sufficient memory available at the moment.  Memory may be
about to be freed up by the system after a domain destruction (i.e. the memory
is being scrubbed asynchronously, and will be released soon).

Closes bug #407, bug #429.

Signed-off-by: Ewan Mellor <ewan@xxxxxxxxxxxxx>

xen-unstable cset: 8e74f2cf985ed5ba10b11f9713ffe35be6ec2af5
committer: Robert Read <robert@xxxxxxxxxxxxx>

diff -r bdaa231489ab -r 809440d54834 tools/python/xen/xend/balloon.py
--- a/tools/python/xen/xend/balloon.py  Thu Dec  8 04:10:22 2005
+++ b/tools/python/xen/xend/balloon.py  Thu Dec  8 04:13:06 2005
@@ -30,52 +30,95 @@
 PROC_XEN_BALLOON = "/proc/xen/balloon"
 BALLOON_OUT_SLACK = 1 # MiB.  We need this because the physinfo details are
                       # rounded.
+RETRY_LIMIT = 10
+##
+# The time to sleep between retries grows linearly, using this value (in
+# seconds).  When the system is lightly loaded, memory should be scrubbed and
+# returned to the system very quickly, whereas when it is loaded, the system
+# needs idle time to get the scrubbing done.  This linear growth accommodates
+# such requirements.
+SLEEP_TIME_GROWTH = 0.1
 
 
 def free(required):
     """Balloon out memory from the privileged domain so that there is the
     specified required amount (in KiB) free.
     """
-    
+
+    # We check whether there is enough free memory, and if not, instruct dom0
+    # to balloon out to free some up.  Memory freed by a destroyed domain may
+    # not appear in the free_memory field immediately, because it needs to be
+    # scrubbed before it can be released to the free list, which is done
+    # asynchronously by Xen; ballooning is asynchronous also.  No matter where
+    # we expect the free memory to come from, therefore, we need to wait for
+    # it to become available.
+    #
+    # We are not allowed to balloon below dom0_min_mem, or if dom0_min_mem
+    # is 0, we cannot balloon at all.  Memory can still become available
+    # through a rebooting domain, however.
+    #
+    # Eventually, we time out (presumably because there really isn't enough
+    # free memory).
+    #
+    # We don't want to set the memory target (triggering a watch) when that
+    # has already been done, but we do want to respond to changing memory
+    # usage, so we recheck the required alloc each time around the loop, but
+    # track the last used value so that we don't trigger too many watches.
+
+    need_mem = (required + 1023) / 1024 + BALLOON_OUT_SLACK
+
+    xroot = XendRoot.instance()
     xc = xen.lowlevel.xc.xc()
-    xroot = XendRoot.instance()
 
     try:
-        free_mem = xc.physinfo()['free_memory']
-        need_mem = (required + 1023) / 1024 + BALLOON_OUT_SLACK
+        dom0_min_mem = xroot.get_dom0_min_mem()
 
-        log.debug("Balloon: free %d; need %d.", free_mem, need_mem)
-        
-        if free_mem >= need_mem:
-            return
+        retries = 0
+        sleep_time = SLEEP_TIME_GROWTH
+        last_new_alloc = None
+        while retries < RETRY_LIMIT:
+            free_mem = xc.physinfo()['free_memory']
 
-        dom0_min_mem = xroot.get_dom0_min_mem()
+            if free_mem >= need_mem:
+                log.debug("Balloon: free %d; need %d; done.", free_mem,
+                          need_mem)
+                return
+
+            if retries == 0:
+                log.debug("Balloon: free %d; need %d.", free_mem, need_mem)
+
+            if dom0_min_mem > 0:
+                dom0_alloc = _get_dom0_alloc()
+                new_alloc = dom0_alloc - (need_mem - free_mem)
+
+                if (new_alloc >= dom0_min_mem and
+                    new_alloc != last_new_alloc):
+                    log.debug("Balloon: setting dom0 target to %d.",
+                              new_alloc)
+                    dom0 = XendDomain.instance().privilegedDomain()
+                    dom0.setMemoryTarget(new_alloc)
+                    last_new_alloc = new_alloc
+                    # Continue to retry, waiting for ballooning.
+
+            time.sleep(sleep_time)
+            retries += 1
+            sleep_time += SLEEP_TIME_GROWTH
+
+        # Not enough memory; diagnose the problem.
         if dom0_min_mem == 0:
-            raise VmError('Not enough free memory and dom0_min_mem is 0.')
-
-        dom0_alloc = _get_dom0_alloc()
-        dom0_new_alloc = dom0_alloc - (need_mem - free_mem)
-        if dom0_new_alloc < dom0_min_mem:
+            raise VmError(('Not enough free memory and dom0_min_mem is 0, so '
+                           'I cannot release any more.  I need %d MiB but '
+                           'only have %d.') %
+                          (need_mem, free_mem))
+        elif new_alloc >= dom0_min_mem:
             raise VmError(
                 ('I need %d MiB, but dom0_min_mem is %d and shrinking to '
                  '%d MiB would leave only %d MiB free.') %
                 (need_mem, dom0_min_mem, dom0_min_mem,
-                 free_mem + (dom0_alloc - dom0_min_mem)))
+                 free_mem + dom0_alloc - dom0_min_mem))
+        else:
+            raise VmError('The privileged domain did not balloon!')
 
-        dom0 = XendDomain.instance().privilegedDomain()
-        dom0.setMemoryTarget(dom0_new_alloc)
-
-        timeout = 20 # 2 sec
-        while timeout > 0:
-            time.sleep(0.1)
-
-            free_mem = xc.physinfo()['free_memory']
-            if free_mem >= need_mem:
-                return
-
-            timeout -= 1
-
-        raise VmError('The privileged domain did not balloon!')
     finally:
         del xc
 

_______________________________________________
Xen-changelog mailing list
Xen-changelog@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-changelog