def setUp(self):
'''
Sets all the reqd parameter and also
mounts the tmpfs to be used in test.
'''
# Set params as per available memory in system
self.mem_path = os.path.join(data_dir.get_tmp_dir(), 'thp_space')
free_mem = int(memory.freememtotal() / 1024)
self.dd_timeout = 900
self.thp_split = None
try:
memory.read_from_vmstat("thp_split_page")
self.thp_split = "thp_split_page"
except IndexError:
self.thp_split = "thp_split"
# Set block size as hugepage size * 2
self.block_size = (memory.get_huge_page_size() / 1024) * 2
self.count = free_mem / self.block_size
# Mount device as per free memory size
if not os.path.exists(self.mem_path):
os.makedirs(self.mem_path)
self.device = Partition(device="none", mountpoint=self.mem_path)
self.device.mount(mountpoint=self.mem_path, fstype="tmpfs",
args='-o size=%dM' % free_mem)
def setUp(self):
'''
Sets all the reqd parameter and also
mounts the tmpfs to be used in test.
'''
# Set params as per available memory in system
self.mem_path = os.path.join(data_dir.get_tmp_dir(), 'thp_space')
free_mem = int(memory.freememtotal() / 1024)
self.dd_timeout = 900
self.thp_split = None
try:
memory.read_from_vmstat("thp_split_page")
self.thp_split = "thp_split_page"
except IndexError:
self.thp_split = "thp_split"
# Set block size as hugepage size * 2
self.block_size = (memory.get_huge_page_size() / 1024) * 2
self.count = free_mem / self.block_size
# Mount device as per free memory size
if not os.path.exists(self.mem_path):
os.makedirs(self.mem_path)
self.device = Partition(device="none", mountpoint=self.mem_path)
self.device.mount(mountpoint=self.mem_path,
fstype="tmpfs",
args='-o size=%dM' % free_mem)
def setUp(self):
smm = SoftwareManager()
dist = distro.detect()
memsize = int(memory.meminfo.MemFree.b * 0.2)
self.nr_pages = self.params.get('nr_pages',
default=memsize /
memory.get_page_size())
self.map_type = self.params.get('map_type', default='private')
self.hpage = self.params.get('h_page', default=False)
nodes = memory.numa_nodes_with_memory()
if len(nodes) < 2:
self.cancel('Test requires two numa nodes to run.'
'Node list with memory: %s' % nodes)
pkgs = ['gcc', 'make']
hp_check = 0
if self.hpage:
hp_size = memory.get_huge_page_size()
for node in nodes:
genio.write_file(
'/sys/devices/system/node/node%s/hugepages/hu'
'gepages-%skB/nr_hugepages' % (node, str(hp_size)),
str(self.nr_pages))
for node in nodes:
hp_check += int(
genio.read_file(
'/sys/devices/system/node/node%s/hugepages/hugepages-%skB'
'/nr_hugepages' % (node, str(hp_size))).strip())
if hp_check < self.nr_pages:
self.cancel('Not enough pages to be configured on nodes')
if dist.name == "Ubuntu":
pkgs.extend(
['libpthread-stubs0-dev', 'libnuma-dev', 'libhugetlbfs-dev'])
elif dist.name in ["centos", "rhel", "fedora"]:
pkgs.extend(['numactl-devel', 'libhugetlbfs-devel'])
elif dist.name == "SuSE":
pkgs.extend(['libnuma-devel'])
if dist.version >= 15:
pkgs.extend(['libhugetlbfs-devel'])
else:
pkgs.extend(['libhugetlbfs-libhugetlb-devel'])
for package in pkgs:
if not smm.check_installed(package) and not smm.install(package):
self.cancel('%s is needed for the test to be run' % package)
for file_name in [
'util.c', 'numa_test.c', 'softoffline.c', 'bench_movepages.c',
'Makefile'
]:
self.copyutil(file_name)
build.make(self.teststmpdir)
def setUp(self):
smm = SoftwareManager()
self.hpagesize = int(self.params.get('hpagesize', default=memory.get_huge_page_size()/1024))
self.num_huge = int(self.params.get('num_pages', default='1'))
for package in ['gcc', 'make']:
if not smm.check_installed(package) and not smm.install(package):
self.cancel('%s is needed for the test to be run' % package)
for file_name in ['hugepage_sanity.c', 'Makefile']:
self.copyutil(file_name)
build.make(self.teststmpdir)
def test(self):
'''
Enables THP, Turns off the defrag and fragments the memory.
Once the memory gets fragmented turns on the defrag and checks
whether defrag happened.
'''
# Enables THP
memory.set_thp_value("enabled", "always")
# Turns off Defrag
memory.set_thp_value("khugepaged/defrag", "0")
# Fragments The memory
self.log.info("Fragmenting the memory Using dd command \n")
for iterator in range(self.count):
defrag_cmd = 'dd if=/dev/urandom of=%s/%d bs=%dK count=1'\
% (self.mem_path, iterator, self.block_size)
if (process.system(defrag_cmd,
timeout=900,
verbose=False,
ignore_status=True,
shell=True)):
self.fail('Defrag command Failed %s' % defrag_cmd)
total = memory.memtotal()
hugepagesize = memory.get_huge_page_size()
nr_full = int(0.8 * (total / hugepagesize))
# Sets max possible hugepages before defrag on
nr_hp_before = self.set_max_hugepages(nr_full)
# Turns Defrag ON
memory.set_thp_value("khugepaged/defrag", "1")
self.log.info("Sleeping %d seconds to settle out things", 10)
time.sleep(10)
# Sets max hugepages after defrag on
nr_hp_after = self.set_max_hugepages(nr_full)
# Check for memory defragmentation
if nr_hp_before >= nr_hp_after:
e_msg = "No Memory Defragmentation\n"
e_msg += "%d hugepages before turning khugepaged on,\n"\
"%d After it" % (nr_hp_before, nr_hp_after)
self.fail(e_msg)
self.log.info("Defrag test passed")
def setUp(self):
smm = SoftwareManager()
dist = distro.detect()
memsize = int(memory.freememtotal() * 1024 * 0.2)
self.nr_pages = self.params.get(
'nr_pages', default=memsize / memory.get_page_size())
self.map_type = self.params.get('map_type', default='private')
self.hpage = self.params.get('h_page', default=False)
nodes = memory.numa_nodes_with_memory()
if len(nodes) < 2:
self.cancel('Test requires two numa nodes to run.'
'Node list with memory: %s' % nodes)
pkgs = ['gcc', 'make']
hp_check = 0
if self.hpage:
hp_size = memory.get_huge_page_size()
for node in nodes:
genio.write_file('/sys/devices/system/node/node%s/hugepages/hu'
'gepages-%skB/nr_hugepages' %
(node, str(hp_size)), str(self.nr_pages))
for node in nodes:
hp_check += int(genio.read_file(
'/sys/devices/system/node/node%s/hugepages/hugepages-%skB'
'/nr_hugepages' % (node, str(hp_size))).strip())
if hp_check < self.nr_pages:
self.cancel('Not enough pages to be configured on nodes')
if dist.name == "Ubuntu":
pkgs.extend(['libpthread-stubs0-dev',
'libnuma-dev', 'libhugetlbfs-dev'])
elif dist.name in ["centos", "rhel", "fedora"]:
pkgs.extend(['numactl-devel', 'libhugetlbfs-devel'])
elif dist.name == "SuSE":
pkgs.extend(['libnuma-devel'])
if dist.version >= 15:
pkgs.extend(['libhugetlbfs-devel'])
else:
pkgs.extend(['libhugetlbfs-libhugetlb-devel'])
for package in pkgs:
if not smm.check_installed(package) and not smm.install(package):
self.cancel('%s is needed for the test to be run' % package)
for file_name in ['util.c', 'numa_test.c', 'Makefile']:
self.copyutil(file_name)
build.make(self.teststmpdir)
def test(self):
'''
Enables THP, Turns off the defrag and fragments the memory.
Once the memory gets fragmented turns on the defrag and checks
whether defrag happened.
'''
# Enables THP
memory.set_thp_value("enabled", "always")
# Turns off Defrag
memory.set_thp_value("khugepaged/defrag", "0")
# Fragments The memory
self.log.info("Fragmenting the memory Using dd command \n")
for iterator in range(self.count):
defrag_cmd = 'dd if=/dev/urandom of=%s/%d bs=%dK count=1'\
% (self.mem_path, iterator, self.block_size)
if(process.system(defrag_cmd, timeout=900,
verbose=False, ignore_status=True, shell=True)):
self.fail('Defrag command Failed %s' % defrag_cmd)
total = memory.memtotal()
hugepagesize = memory.get_huge_page_size()
nr_full = int(0.8 * (total / hugepagesize))
# Sets max possible hugepages before defrag on
nr_hp_before = self.set_max_hugepages(nr_full)
# Turns Defrag ON
memory.set_thp_value("khugepaged/defrag", "1")
self.log.info("Sleeping %d seconds to settle out things", 10)
time.sleep(10)
# Sets max hugepages after defrag on
nr_hp_after = self.set_max_hugepages(nr_full)
# Check for memory defragmentation
if nr_hp_before >= nr_hp_after:
e_msg = "No Memory Defragmentation\n"
e_msg += "%d hugepages before turning khugepaged on,\n"\
"%d After it" % (nr_hp_before, nr_hp_after)
self.fail(e_msg)
self.log.info("Defrag test passed")
def setUp(self):
smm = SoftwareManager()
self.hpagesize = int(
self.params.get('hpagesize',
default=memory.get_huge_page_size() / 1024))
cpu_info = genio.read_file("/proc/cpuinfo")
if 'Radix' in cpu_info and self.hpagesize == 16:
self.cancel("This hugepage size is not supported.")
if 'Hash' in cpu_info and self.hpagesize != 16:
self.cancel("This hugepage size is not supported.")
self.num_huge = int(self.params.get('num_pages', default='1'))
for package in ['gcc', 'make']:
if not smm.check_installed(package) and not smm.install(package):
self.cancel('%s is needed for the test to be run' % package)
for file_name in ['hugepage_sanity.c', 'Makefile']:
self.copyutil(file_name)
build.make(self.teststmpdir)
def setUp(self):
'''
Sets all the reqd parameter and also
mounts the tmpfs to be used in test.
'''
# Set params as per available memory in system
self.mem_path = os.path.join(data_dir.get_tmp_dir(), 'thp_space')
free_mem = int(memory.freememtotal() / 1024)
self.dd_timeout = 900
# Set block size as hugepage size * 2
self.block_size = (memory.get_huge_page_size() / 1024) * 2
self.count = free_mem / self.block_size
# Mount device as per free memory size
os.mkdir(self.mem_path)
self.device = Partition(device="none", mountpoint=self.mem_path)
self.device.mount(mountpoint=self.mem_path, fstype="tmpfs",
args='-o size=%dM' % free_mem)
def run(test, params, env):
"""
Qemu allocate hugepage from specify node.
Steps:
1) Setup total of 4G mem hugepages for specify node.
2) Setup total of 1G mem hugepages for idle node.
3) Mount this hugepage to /mnt/kvm_hugepage.
4) Boot guest only allocate hugepage from specify node.
5) Check the hugepage used from every node.
:params test: QEMU test object.
:params params: Dictionary with the test parameters.
:params env: Dictionary with test environment.
"""
memory.drop_caches()
hugepage_size = memory.get_huge_page_size()
mem_size = int(normalize_data_size("%sM" % params["mem"], "K"))
idle_node_mem = int(normalize_data_size("%sM" % params["idle_node_mem"], "K"))
error_context.context("Get host numa topological structure.", logging.info)
host_numa_node = utils_misc.NumaInfo()
node_list = host_numa_node.get_online_nodes_withmem()
idle_node_list = node_list.copy()
node_meminfo = host_numa_node.get_all_node_meminfo()
for node_id in node_list:
error_context.base_context("Check preprocess HugePages Free on host "
"numa node %s." % node_id, logging.info)
node_memfree = int(node_meminfo[node_id]["MemFree"])
if node_memfree < idle_node_mem:
idle_node_list.remove(node_id)
if node_memfree < mem_size:
node_list.remove(node_id)
if len(idle_node_list) < 2 or not node_list:
test.cancel("Host node does not have enough nodes to run the test, "
"skipping test...")
for node_id in node_list:
error_context.base_context("Specify qemu process only allocate "
"HugePages from node%s." % node_id, logging.info)
params["target_nodes"] = "%s" % node_id
params["target_num_node%s" % node_id] = math.ceil(mem_size / hugepage_size)
error_context.context("Setup huge pages for specify node%s." %
node_id, logging.info)
check_list = [_ for _ in idle_node_list if _ != node_id]
for idle_node in check_list:
params["target_nodes"] += " %s" % idle_node
params["target_num_node%s" % idle_node] = math.ceil(idle_node_mem / hugepage_size)
error_context.context("Setup huge pages for idle node%s." %
idle_node, logging.info)
params["setup_hugepages"] = "yes"
hp_config = test_setup.HugePageConfig(params)
hp_config.setup()
params["qemu_command_prefix"] = "numactl --membind=%s" % node_id
params["start_vm"] = "yes"
params["hugepage_path"] = hp_config.hugepage_path
env_process.preprocess_vm(test, params, env, params["main_vm"])
try:
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
vm.wait_for_login()
meminfo = host_numa_node.get_all_node_meminfo()
for index in check_list:
error_context.base_context("Check process HugePages Free on host "
"numa node %s." % index, logging.info)
hugepages_free = int(meminfo[index]["HugePages_Free"])
if int(node_meminfo[index]["HugePages_Free"]) > hugepages_free:
test.fail("Qemu still use HugePages from other node."
"Expect: node%s, used: node%s." % (node_id, index))
finally:
vm.destroy()
hp_config.cleanup()
