def setUp(self):
'''
Use 85% of memory with/without many process forked
WARNING: System may go out-of-memory based on the available resource
'''
smm = SoftwareManager()
self.itern = int(self.params.get('iterations', default='10'))
self.procs = int(self.params.get('procs', default='1'))
self.minmem = int(self.params.get('minmem', default='10'))
self.fails = []
if not (self.itern and self.procs and self.minmem):
self.cancel(
'Please use a non-zero value for number'
' of iterations, processes and memory to be used')
self.freemem = int((0.85 * memory.freememtotal()) / 1024)
# Check for basic utilities
for packages in ['gcc', 'make']:
if not smm.check_installed(packages) and not smm.install(packages):
self.cancel('%s is needed for the test to be run' % packages)
shutil.copyfile(self.get_data('forkoff.c'),
os.path.join(self.teststmpdir, 'forkoff.c'))
shutil.copyfile(self.get_data('Makefile'),
os.path.join(self.teststmpdir, 'Makefile'))
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
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 test(self):
'''
Run memtester
'''
mem = self.params.get('memory',
default=int(memory.freememtotal() / 1024))
runs = self.params.get('runs', default=1)
phyaddr = self.params.get('physaddr', default=None)
# Basic Memtester usecase
if process.system("./memtester %s %s" % (mem, runs),
verbose=True,
sudo=True,
ignore_status=True):
self.fail("memtester failed for free space %s" % mem)
if phyaddr:
# To verify -p option if provided in the yaml file
device = self.params.get('device', default='/dev/mem')
if process.system("./memtester -p %s -d %s %s %s" %
(phyaddr, device, mem, runs),
verbose=True,
sudo=True,
ignore_status=True):
self.fail("memtester failed for address %s" % phyaddr)
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')
if len(memory.numa_nodes()) < 2:
self.cancel('Test requires two numa nodes to run')
pkgs = ['gcc', 'make']
if dist.name == "Ubuntu":
pkgs.extend(['libpthread-stubs0-dev', 'libnuma-dev'])
elif dist.name in ["centos", "rhel", "fedora"]:
pkgs.extend(['numactl-devel'])
else:
pkgs.extend(['libnuma-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 setUp(self):
'''
Use 85% of memory with/without many process forked
WARNING: System may go out-of-memory based on the available resource
'''
smm = SoftwareManager()
self.itern = int(self.params.get('iterations', default='10'))
self.procs = int(self.params.get('procs', default='1'))
self.minmem = int(self.params.get('minmem', default='10'))
self.fails = []
if not (self.itern and self.procs and self.minmem):
self.cancel('Please use a non-zero value for number'
' of iterations, processes and memory to be used')
self.freemem = int((0.85 * memory.freememtotal()) / 1024)
# Check for basic utilities
for packages in ['gcc', 'make']:
if not smm.check_installed(packages) and not smm.install(packages):
self.cancel('%s is needed for the test to be run' % packages)
shutil.copyfile(self.get_data('forkoff.c'),
os.path.join(self.teststmpdir, 'forkoff.c'))
shutil.copyfile(self.get_data('Makefile'),
os.path.join(self.teststmpdir, 'Makefile'))
build.make(self.teststmpdir)
def setUp(self):
smm = SoftwareManager()
self.memsize = int(self.params.get(
'memory_size', default=(memory.freememtotal() / 1024)) * 1048576 * 0.5)
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 ['memory_api.c', 'mremap.c', 'Makefile']:
self.copyutil(file_name)
build.make(self.teststmpdir)
def setUp(self):
smm = SoftwareManager()
self.memsize = int(self.params.get(
'memory_size', default=(memory.freememtotal() / 1024)) * 1048576 * 0.5)
self.induce_err = self.params.get('induce_err', default=0)
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 ['memory_api.c', 'mremap.c', 'Makefile']:
self.copyutil(file_name)
build.make(self.teststmpdir)
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 setUp(self):
"""
Sets up the args required to run the test.
"""
sm = SoftwareManager()
detected_distro = distro.detect()
# FIXME: "redhat" as the distro name for RHEL is deprecated
# on Avocado versions >= 50.0. This is a temporary compatibility
# enabler for older runners, but should be removed soon
if detected_distro.name not in ['Ubuntu', 'rhel', 'redhat']:
self.skip('Test Not applicable')
if detected_distro.name == "Ubuntu":
deps = ['memcached', 'libmemcached-tools']
stress_tool = 'memcslap'
# FIXME: "redhat" as the distro name for RHEL is deprecated
# on Avocado versions >= 50.0. This is a temporary compatibility
# enabler for older runners, but should be removed soon
if detected_distro.name in ["rhel", "redhat"]:
deps = ['memcached', 'libmemcached']
stress_tool = 'memslap'
for package in deps:
if not sm.check_installed(package) and not sm.install(package):
self.error(' %s is needed for the test to be run' % package)
# Memcached Required Args
memory_to_use = self.params.get("memory_to_use",
default=(memory.freememtotal() / 1024))
port_no = self.params.get("port_no", default='12111')
memcached_args = self.params.get('memcached_args', default='')
self.memcached_cmd = 'memcached -u %s -p %s -m %d %s &'\
% (getpass.getuser(), port_no, memory_to_use,
memcached_args)
# Memcached stress tool required Args
# For more options : memcslap --help
system_ip = self.params.get('system_ip', default='127.0.0.1')
test_to_run = self.params.get('test_to_run', default='get')
concurrency = self.params.get('concurrency', default='100')
stress_tool_args = self.params.get('stress_tool_args', default='')
self.stress_tool_cmd = '%s -s %s:%s --test %s --verbose '\
'--concurrency %s %s' % (stress_tool,
system_ip, port_no,
test_to_run,
concurrency,
stress_tool_args)
def test(self):
"""
Execute 'stress' with proper arguments.
"""
length = self.params.get('stress_lenght', default=60)
threads = self.params.get('threads', default=None)
memory_per_thread = self.params.get('memory_per_thread', default=None)
file_size_per_thread = self.params.get('file_size_per_thread',
default=None)
if threads is None:
# We will use 2 workers of each type for each CPU detected
threads = 2 * multiprocessing.cpu_count()
if memory_per_thread is None:
# Sometimes the default memory used by each memory worker (256 M)
# might make our machine go OOM and then funny things might start
# to happen. Let's avoid that.
mb = (memory.freememtotal() +
memory.read_from_meminfo('SwapFree') / 2)
memory_per_thread = (mb * 1024) / threads
if file_size_per_thread is None:
# Even though unlikely, it's good to prevent from allocating more
# disk than this machine actually has on its autotest directory
# (limit the amount of disk used to max of 90 % of free space)
free_disk = disk.freespace(self.sourcedir)
file_size_per_thread = 1024 ** 2
if (0.9 * free_disk) < file_size_per_thread * threads:
file_size_per_thread = (0.9 * free_disk) / threads
# Number of CPU workers spinning on sqrt()
args = '--cpu %d ' % threads
# Number of IO workers spinning on sync()
args += '--io %d ' % threads
# Number of Memory workers spinning on malloc()/free()
args += '--vm %d ' % threads
# Amount of memory used per each worker
args += '--vm-bytes %d ' % memory_per_thread
# Number of HD workers spinning on write()/ulink()
args += '--hdd %d ' % threads
# Size of the files created by each worker in bytes
args += '--hdd-bytes %d ' % file_size_per_thread
# Time for which the stress test will run
args += '--timeout %d ' % length
# Verbose flag
args += '--verbose'
os.chdir(self.sourcedir)
cmd = ('./src/stress %s' % args)
process.run(cmd)
def test(self):
"""
Execute 'stress' with proper arguments.
"""
length = self.params.get('stress_lenght', default=60)
threads = self.params.get('threads', default=None)
memory_per_thread = self.params.get('memory_per_thread', default=None)
file_size_per_thread = self.params.get('file_size_per_thread',
default=None)
if threads is None:
# We will use 2 workers of each type for each CPU detected
threads = 2 * multiprocessing.cpu_count()
if memory_per_thread is None:
# Sometimes the default memory used by each memory worker (256 M)
# might make our machine go OOM and then funny things might start
# to happen. Let's avoid that.
mb = (memory.freememtotal() +
memory.read_from_meminfo('SwapFree') / 2)
memory_per_thread = (mb * 1024) / threads
if file_size_per_thread is None:
# Even though unlikely, it's good to prevent from allocating more
# disk than this machine actually has on its autotest directory
# (limit the amount of disk used to max of 90 % of free space)
free_disk = disk.freespace(self.sourcedir)
file_size_per_thread = 1024**2
if (0.9 * free_disk) < file_size_per_thread * threads:
file_size_per_thread = (0.9 * free_disk) / threads
# Number of CPU workers spinning on sqrt()
args = '--cpu %d ' % threads
# Number of IO workers spinning on sync()
args += '--io %d ' % threads
# Number of Memory workers spinning on malloc()/free()
args += '--vm %d ' % threads
# Amount of memory used per each worker
args += '--vm-bytes %d ' % memory_per_thread
# Number of HD workers spinning on write()/ulink()
args += '--hdd %d ' % threads
# Size of the files created by each worker in bytes
args += '--hdd-bytes %d ' % file_size_per_thread
# Time for which the stress test will run
args += '--timeout %d ' % length
# Verbose flag
args += '--verbose'
os.chdir(self.sourcedir)
cmd = ('./src/stress %s' % args)
process.run(cmd)
def test(self):
os.chdir(self.teststmpdir)
proc = process.SubProcess('./memory_api %s ' % self.memsize,
shell=True, allow_output_check='both')
proc.start()
while proc.poll() is None:
pass
if proc.poll() != 0:
self.fail("Unexpected application abort, check for possible issues")
self.log.info("Testing mremap with minimal memory and expand it")
if process.system('./mremap %s' % str(int(memory.freememtotal())), ignore_status=True):
self.fail('Mremap expansion failed')
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 setUp(self):
smm = SoftwareManager()
memsize = int(memory.freememtotal() * 1024 * 0.9)
self.nr_pages = self.params.get('nr_pages', default=None)
self.in_err = self.params.get('induce_err', default=0)
self.failure = self.params.get('failure', default=False)
if not self.nr_pages:
self.nr_pages = memsize / memory.get_page_size()
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 ['mprotect.c', 'Makefile']:
self.copyutil(file_name)
build.make(self.teststmpdir)
def setUp(self):
smm = SoftwareManager()
memsize = int(memory.freememtotal() * 1024 * 0.9)
self.nr_pages = self.params.get('nr_pages', default=None)
self.in_err = self.params.get('induce_err', default=0)
self.failure = self.params.get('failure', default=False)
if not self.nr_pages:
self.nr_pages = memsize / memory.get_page_size()
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 ['mprotect.c', 'Makefile']:
self.copyutil(file_name)
build.make(self.teststmpdir)
def test(self):
os.chdir(self.teststmpdir)
proc = process.SubProcess('./memory_api %s %s' % (self.memsize, self.induce_err),
shell=True, allow_output_check='both')
proc.start()
while proc.poll() is None:
pass
ret = process.system('./memory_api %s 1' % self.memsize,
shell=True, ignore_status=True)
if ret == 255:
self.log.info("Error obtained as expected")
if proc.poll() != 0:
self.fail("Unexpected application abort, check for possible issues")
self.log.info("Testing mremap with minimal memory and expand it")
if process.system('./mremap %s' % str(int(memory.freememtotal())), ignore_status=True):
self.fail('Mremap expansion failed')
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 test(self):
'''
Run memtester
'''
mem = self.params.get('memory', default=int(
memory.freememtotal() / 1024))
runs = self.params.get('runs', default=1)
phyaddr = self.params.get('physaddr', default=None)
# Basic Memtester usecase
if process.system("./memtester %s %s" % (mem, runs), verbose=True,
sudo=True,
ignore_status=True):
self.fail("memtester failed for free space %s" % mem)
if phyaddr:
# To verify -p option if provided in the yaml file
device = self.params.get('device', default='/dev/mem')
if process.system("./memtester -p %s -d %s %s %s" %
(phyaddr, device, mem, runs), verbose=True,
sudo=True, ignore_status=True):
self.fail("memtester failed for address %s" % phyaddr)
