qmemman: reformat code, especially comments
Indent comments to match code indentation to make it readable. Also, wrap long lines. Fix few typos in comments. No functional change.
This commit is contained in:
Marek Marczykowski-Górecki
parent
a66c9afb18
commit
8e288d9f81
@ -45,7 +45,8 @@ class DomainState:
|
||||
self.id = id # domain id
|
||||
self.last_target = 0 # the last memset target
|
||||
self.no_progress = False # no react to memset
|
||||
self.slow_memset_react = False #slow react to memset (after few tries still above target)
|
||||
self.slow_memset_react = False # slow react to memset (after few
|
||||
# tries still above target)
|
||||
|
||||
def __repr__(self):
|
||||
return self.__dict__.__repr__()
|
||||
@ -61,9 +62,11 @@ class SystemState(object):
|
||||
self.BALOON_DELAY = 0.1
|
||||
self.XEN_FREE_MEM_LEFT = 50*1024*1024
|
||||
self.XEN_FREE_MEM_MIN = 25*1024*1024
|
||||
# Overhead of per-page Xen structures, taken from OpenStack nova/virt/xenapi/driver.py
|
||||
# Overhead of per-page Xen structures, taken from OpenStack
|
||||
# nova/virt/xenapi/driver.py
|
||||
# see https://wiki.openstack.org/wiki/XenServer/Overhead
|
||||
# we divide total and free physical memory by this to get "assignable" memory
|
||||
# we divide total and free physical memory by this to get
|
||||
# "assignable" memory
|
||||
self.MEM_OVERHEAD_FACTOR = 1.0 / 1.00781
|
||||
try:
|
||||
self.ALL_PHYS_MEM = int(self.xc.physinfo()['total_memory']*1024 * self.MEM_OVERHEAD_FACTOR)
|
||||
@ -126,17 +129,20 @@ class SystemState(object):
|
||||
else:
|
||||
self.domdict[id].memory_maximum = self.ALL_PHYS_MEM
|
||||
# the previous line used to be
|
||||
# self.domdict[id].memory_maximum = domain['maxmem_kb']*1024
|
||||
# but domain['maxmem_kb'] changes in self.mem_set as well, and this results in
|
||||
# the memory never increasing
|
||||
# in fact, the only possible case of nonexisting memory/static-max is dom0
|
||||
# self.domdict[id].memory_maximum = domain[
|
||||
# 'maxmem_kb']*1024
|
||||
# but domain['maxmem_kb'] changes in self.mem_set as well,
|
||||
# and this results in the memory never increasing
|
||||
# in fact, the only possible case of nonexisting
|
||||
# memory/static-max is dom0
|
||||
# see #307
|
||||
|
||||
def clear_outdated_error_markers(self):
|
||||
# Clear outdated errors
|
||||
for i in self.domdict.keys():
|
||||
if self.domdict[i].slow_memset_react and \
|
||||
self.domdict[i].memory_actual <= self.domdict[i].last_target + self.XEN_FREE_MEM_LEFT/4:
|
||||
self.domdict[i].memory_actual <= \
|
||||
self.domdict[i].last_target + self.XEN_FREE_MEM_LEFT/4:
|
||||
dom_name = self.xs.read('', '/local/domain/%s/name' % str(i))
|
||||
if dom_name is not None:
|
||||
# TODO: report it somewhere, qubesd or elsewhere
|
||||
@ -144,14 +150,16 @@ class SystemState(object):
|
||||
self.domdict[i].slow_memset_react = False
|
||||
|
||||
if self.domdict[i].no_progress and \
|
||||
self.domdict[i].memory_actual <= self.domdict[i].last_target + self.XEN_FREE_MEM_LEFT/4:
|
||||
self.domdict[i].memory_actual <= \
|
||||
self.domdict[i].last_target + self.XEN_FREE_MEM_LEFT/4:
|
||||
dom_name = self.xs.read('', '/local/domain/%s/name' % str(i))
|
||||
if dom_name is not None:
|
||||
# TODO: report it somewhere, qubesd or elsewhere
|
||||
pass
|
||||
self.domdict[i].no_progress = False
|
||||
|
||||
#the below works (and is fast), but then 'xm list' shows unchanged memory value
|
||||
# the below works (and is fast), but then 'xm list' shows unchanged
|
||||
# memory value
|
||||
def mem_set(self, id, val):
|
||||
self.log.info('mem-set domain {} to {}'.format(id, val))
|
||||
self.domdict[id].last_target = val
|
||||
@ -175,7 +183,8 @@ class SystemState(object):
|
||||
'Preventing balloon up to {}'.format(dom.last_target))
|
||||
self.mem_set(i, dom.memory_actual)
|
||||
|
||||
#perform memory ballooning, across all domains, to add "memsize" to Xen free memory
|
||||
# perform memory ballooning, across all domains, to add "memsize" to Xen
|
||||
# free memory
|
||||
def do_balloon(self, memsize):
|
||||
self.log.info('do_balloon(memsize={!r})'.format(memsize))
|
||||
CHECK_PERIOD_S = 3
|
||||
@ -213,7 +222,8 @@ class SystemState(object):
|
||||
if prev_memory_actual is not None:
|
||||
for i in prev_memory_actual.keys():
|
||||
if prev_memory_actual[i] == self.domdict[i].memory_actual:
|
||||
#domain not responding to memset requests, remove it from donors
|
||||
# domain not responding to memset requests, remove it
|
||||
# from donors
|
||||
self.domdict[i].no_progress = True
|
||||
self.log.info('domain {} stuck at {}'.format(i, self.domdict[i].memory_actual))
|
||||
memset_reqs = qubes.qmemman.algo.balloon(memsize + self.XEN_FREE_MEM_LEFT - xenfree, self.domdict)
|
||||
@ -261,7 +271,8 @@ class SystemState(object):
|
||||
total_memory_transfer += abs(memory_change)
|
||||
pref = qubes.qmemman.algo.prefmem(self.domdict[dom])
|
||||
|
||||
if last_target > 0 and last_target < pref and memory_change > MIN_MEM_CHANGE_WHEN_UNDER_PREF:
|
||||
if 0 < last_target < pref and \
|
||||
memory_change > MIN_MEM_CHANGE_WHEN_UNDER_PREF:
|
||||
self.log.info(
|
||||
'dom {} is below pref, allowing balance'.format(dom))
|
||||
return True
|
||||
@ -303,7 +314,7 @@ class SystemState(object):
|
||||
dom, mem = rq
|
||||
# Force to always have at least 0.9*self.XEN_FREE_MEM_LEFT (some
|
||||
# margin for rounding errors). Before giving memory to
|
||||
# domain, ensure that others have gived it back.
|
||||
# domain, ensure that others have gave it back.
|
||||
# If not - wait a little.
|
||||
ntries = 5
|
||||
while self.get_free_xen_memory() - (mem - self.domdict[dom].memory_actual) < 0.9*self.XEN_FREE_MEM_LEFT:
|
||||
@ -318,11 +329,12 @@ class SystemState(object):
|
||||
for rq2 in memset_reqs:
|
||||
dom2, mem2 = rq2
|
||||
if dom2 == dom:
|
||||
# All donors have been procesed
|
||||
# All donors have been processed
|
||||
break
|
||||
# allow some small margin
|
||||
if self.domdict[dom2].memory_actual > self.domdict[dom2].last_target + self.XEN_FREE_MEM_LEFT/4:
|
||||
# VM didn't react to memory request at all, remove from donors
|
||||
# VM didn't react to memory request at all,
|
||||
# remove from donors
|
||||
if prev_memactual[dom2] == self.domdict[dom2].memory_actual:
|
||||
self.log.warning(
|
||||
'dom {!r} didnt react to memory request'
|
||||
@ -333,7 +345,8 @@ class SystemState(object):
|
||||
self.domdict[dom2].no_progress = True
|
||||
dom_name = self.xs.read('', '/local/domain/%s/name' % str(dom2))
|
||||
if dom_name is not None:
|
||||
# TODO: report it somewhere, qubesd or elsewhere
|
||||
# TODO: report it somewhere, qubesd or
|
||||
# elsewhere
|
||||
pass
|
||||
else:
|
||||
self.log.warning('dom {!r} still hold more'
|
||||
@ -344,7 +357,8 @@ class SystemState(object):
|
||||
self.domdict[dom2].slow_memset_react = True
|
||||
dom_name = self.xs.read('', '/local/domain/%s/name' % str(dom2))
|
||||
if dom_name is not None:
|
||||
# TODO: report it somewhere, qubesd or elsewhere
|
||||
# TODO: report it somewhere, qubesd or
|
||||
# elsewhere
|
||||
pass
|
||||
self.mem_set(dom, self.get_free_xen_memory() + self.domdict[dom].memory_actual - self.XEN_FREE_MEM_LEFT)
|
||||
return
|
||||
|
||||
@ -29,9 +29,9 @@ CACHE_FACTOR = 1.3
|
||||
MIN_PREFMEM = 200 * 1024 * 1024
|
||||
DOM0_MEM_BOOST = 350 * 1024 * 1024
|
||||
|
||||
|
||||
log = logging.getLogger('qmemman.daemon.algo')
|
||||
|
||||
|
||||
# untrusted meminfo size is taken from xenstore key, thus its size is limited
|
||||
# so splits do not require excessive memory
|
||||
def sanitize_and_parse_meminfo(untrusted_meminfo):
|
||||
@ -65,7 +65,6 @@ def sanitize_and_parse_meminfo(untrusted_meminfo):
|
||||
meminfo['MemFree'] - meminfo['Cached'] - meminfo['Buffers'] +
|
||||
meminfo['SwapTotal'] - meminfo['SwapFree']) * 1024
|
||||
|
||||
|
||||
return None
|
||||
|
||||
|
||||
@ -89,7 +88,8 @@ def is_meminfo_suspicious(untrusted_meminfo):
|
||||
ret = True
|
||||
if untrusted_meminfo['MemTotal'] < \
|
||||
untrusted_meminfo['MemFree'] + \
|
||||
untrusted_meminfo['Cached'] + untrusted_meminfo['Buffers']:
|
||||
untrusted_meminfo['Cached'] + untrusted_meminfo[
|
||||
'Buffers']:
|
||||
ret = True
|
||||
# we could also impose some limits on all the above values
|
||||
# but it has little purpose - all the domain can gain by passing e.g.
|
||||
@ -97,7 +97,8 @@ def is_meminfo_suspicious(untrusted_meminfo):
|
||||
# it can be achieved with legal values, too, and it will not allow to
|
||||
# starve existing domains, by design
|
||||
if ret:
|
||||
log.warning('suspicious meminfo untrusted_meminfo={!r}'.format(untrusted_meminfo))
|
||||
log.warning('suspicious meminfo untrusted_meminfo={!r}'.format(
|
||||
untrusted_meminfo))
|
||||
return ret
|
||||
|
||||
|
||||
@ -107,17 +108,23 @@ def refresh_meminfo_for_domain(domain, untrusted_xenstore_key):
|
||||
|
||||
|
||||
def prefmem(domain):
|
||||
#dom0 is special, as it must have large cache, for vbds. Thus, give it a special boost
|
||||
# dom0 is special, as it must have large cache, for vbds. Thus, give it
|
||||
# a special boost
|
||||
if domain.id == '0':
|
||||
return min(domain.mem_used*CACHE_FACTOR + DOM0_MEM_BOOST, domain.memory_maximum)
|
||||
return max(min(domain.mem_used*CACHE_FACTOR, domain.memory_maximum), MIN_PREFMEM)
|
||||
return min(domain.mem_used * CACHE_FACTOR + DOM0_MEM_BOOST,
|
||||
domain.memory_maximum)
|
||||
return max(min(domain.mem_used * CACHE_FACTOR, domain.memory_maximum),
|
||||
MIN_PREFMEM)
|
||||
|
||||
|
||||
def memory_needed(domain):
|
||||
# do not change
|
||||
#in balance(), "distribute total_available_memory proportionally to mempref" relies on this exact formula
|
||||
# in balance(), "distribute total_available_memory proportionally to
|
||||
# mempref" relies on this exact formula
|
||||
ret = prefmem(domain) - domain.memory_actual
|
||||
return ret
|
||||
|
||||
|
||||
# prepare list of (domain, memory_target) pairs that need to be passed
|
||||
# to "xm memset" equivalent in order to obtain "memsize" of memory
|
||||
# return empty list when the request cannot be satisfied
|
||||
@ -146,17 +153,21 @@ def balloon(memsize, domain_dictionary):
|
||||
return ()
|
||||
scale = 1.0 * memsize / available
|
||||
for donors_iter in donors:
|
||||
id, mem = donors_iter
|
||||
dom_id, mem = donors_iter
|
||||
memborrowed = mem * scale * REQ_SAFETY_NET_FACTOR
|
||||
log.info('borrow {} from {}'.format(memborrowed, id))
|
||||
memtarget = int(domain_dictionary[id].memory_actual - memborrowed)
|
||||
request.append((id, memtarget))
|
||||
log.info('borrow {} from {}'.format(memborrowed, dom_id))
|
||||
memtarget = int(domain_dictionary[dom_id].memory_actual - memborrowed)
|
||||
request.append((dom_id, memtarget))
|
||||
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
|
||||
# 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):
|
||||
log.info('balance_when_enough_memory(xen_free_memory={!r}, '
|
||||
@ -174,7 +185,8 @@ def balance_when_enough_memory(domain_dictionary,
|
||||
continue
|
||||
# distribute total_available_memory proportionally to mempref
|
||||
scale = 1.0 * prefmem(domain_dictionary[i]) / total_mem_pref
|
||||
target_nonint = prefmem(domain_dictionary[i]) + scale*total_available_memory
|
||||
target_nonint = prefmem(
|
||||
domain_dictionary[i]) + scale * total_available_memory
|
||||
# prevent rounding errors
|
||||
target = int(0.999 * target_nonint)
|
||||
# do not try to give more memory than static max
|
||||
@ -197,7 +209,8 @@ def balance_when_enough_memory(domain_dictionary,
|
||||
if target < domain_dictionary[i].memory_maximum:
|
||||
memory_bonus = int(0.999 * (left_memory / acceptors_count))
|
||||
if target + memory_bonus >= domain_dictionary[i].memory_maximum:
|
||||
new_left_memory += target+memory_bonus - domain_dictionary[i].memory_maximum
|
||||
new_left_memory += target + memory_bonus - \
|
||||
domain_dictionary[i].memory_maximum
|
||||
target = domain_dictionary[i].memory_maximum
|
||||
new_acceptors_count -= 1
|
||||
else:
|
||||
@ -206,22 +219,24 @@ def balance_when_enough_memory(domain_dictionary,
|
||||
left_memory = new_left_memory
|
||||
acceptors_count = new_acceptors_count
|
||||
# split target_memory dictionary to donors and acceptors
|
||||
# this is needed to first get memory from donors and only then give it to acceptors
|
||||
# this is needed to first get memory from donors and only then give it
|
||||
# to acceptors
|
||||
donors_rq = list()
|
||||
acceptors_rq = list()
|
||||
for i in target_memory.keys():
|
||||
target = target_memory[i]
|
||||
if (target < domain_dictionary[i].memory_actual):
|
||||
if target < domain_dictionary[i].memory_actual:
|
||||
donors_rq.append((i, target))
|
||||
else:
|
||||
acceptors_rq.append((i, target))
|
||||
|
||||
# print 'balance(enough): xen_free_memory=', xen_free_memory, 'requests:', donors_rq + acceptors_rq
|
||||
# print 'balance(enough): xen_free_memory=', xen_free_memory, \
|
||||
# 'requests:', donors_rq + acceptors_rq
|
||||
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
|
||||
# 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, total_mem_pref_acceptors, donors, acceptors):
|
||||
log.debug('balance_when_low_on_memory(xen_free_memory={!r}, '
|
||||
@ -233,7 +248,8 @@ def balance_when_low_on_memory(domain_dictionary,
|
||||
for i in donors:
|
||||
avail = -memory_needed(domain_dictionary[i])
|
||||
if avail < 10 * 1024 * 1024:
|
||||
#probably we have already tried making it exactly at prefmem, give up
|
||||
# probably we have already tried making it exactly at prefmem,
|
||||
# give up
|
||||
continue
|
||||
squeezed_mem -= avail
|
||||
donors_rq.append((i, prefmem(domain_dictionary[i])))
|
||||
@ -242,11 +258,14 @@ def balance_when_low_on_memory(domain_dictionary,
|
||||
return donors_rq
|
||||
for i in acceptors:
|
||||
scale = 1.0 * prefmem(domain_dictionary[i]) / total_mem_pref_acceptors
|
||||
target_nonint = domain_dictionary[i].memory_actual + scale*squeezed_mem
|
||||
target_nonint = \
|
||||
domain_dictionary[i].memory_actual + scale * squeezed_mem
|
||||
# do not try to give more memory than static max
|
||||
target = min(int(0.999*target_nonint), domain_dictionary[i].memory_maximum)
|
||||
target = \
|
||||
min(int(0.999 * target_nonint), domain_dictionary[i].memory_maximum)
|
||||
acceptors_rq.append((i, target))
|
||||
# print 'balance(low): xen_free_memory=', xen_free_memory, 'requests:', donors_rq + acceptors_rq
|
||||
# print 'balance(low): xen_free_memory=', xen_free_memory, 'requests:',
|
||||
# donors_rq + acceptors_rq
|
||||
return donors_rq + acceptors_rq
|
||||
|
||||
|
||||
@ -259,9 +278,10 @@ def balance(xen_free_memory, domain_dictionary):
|
||||
xen_free_memory, domain_dictionary))
|
||||
|
||||
# sum of all memory requirements - in other words, the difference between
|
||||
#memory required to be added to domains (acceptors) to make them be at 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.
|
||||
# memory required to be added to domains (acceptors) to make them be
|
||||
# at 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
|
||||
|
||||
# sum of memory preferences of all domains
|
||||
@ -279,8 +299,11 @@ def balance(xen_free_memory, domain_dictionary):
|
||||
if domain_dictionary[i].no_progress:
|
||||
continue
|
||||
need = memory_needed(domain_dictionary[i])
|
||||
# print 'domain' , i, 'act/pref', domain_dictionary[i].memory_actual, prefmem(domain_dictionary[i]), 'need=', need
|
||||
if need < 0 or domain_dictionary[i].memory_actual >= domain_dictionary[i].memory_maximum:
|
||||
# print 'domain' , i, 'act/pref', \
|
||||
# domain_dictionary[i].memory_actual, prefmem(domain_dictionary[i]), \
|
||||
# 'need=', need
|
||||
if need < 0 or domain_dictionary[i].memory_actual >= \
|
||||
domain_dictionary[i].memory_maximum:
|
||||
donors.append(i)
|
||||
else:
|
||||
acceptors.append(i)
|
||||
@ -290,6 +313,8 @@ def balance(xen_free_memory, domain_dictionary):
|
||||
|
||||
total_available_memory = xen_free_memory - total_memory_needed
|
||||
if total_available_memory > 0:
|
||||
return balance_when_enough_memory(domain_dictionary, xen_free_memory, total_mem_pref, total_available_memory)
|
||||
return balance_when_enough_memory(domain_dictionary, xen_free_memory,
|
||||
total_mem_pref, total_available_memory)
|
||||
else:
|
||||
return balance_when_low_on_memory(domain_dictionary, xen_free_memory, total_mem_pref_acceptors, donors, acceptors)
|
||||
return balance_when_low_on_memory(domain_dictionary, xen_free_memory,
|
||||
total_mem_pref_acceptors, donors, acceptors)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user