def setUp(self): """ Setting up the env for the kernel building """ smg = SoftwareManager() self.detected_distro = distro.detect() deps = ['gcc', 'make', 'automake', 'autoconf', 'time', 'bison', 'flex'] if 'Ubuntu' in self.detected_distro.name: deps.extend(['libpopt0', 'libc6', 'libc6-dev', 'libpopt-dev', 'libcap-ng0', 'libcap-ng-dev', 'elfutils', 'libelf1', 'libnuma-dev', 'libfuse-dev', 'libssl-dev']) elif 'SuSE' in self.detected_distro.name: deps.extend(['libpopt0', 'glibc', 'glibc-devel', 'popt-devel', 'libcap2', 'libcap-devel', 'libcap-ng-devel', 'openssl-devel']) elif self.detected_distro.name in ['centos', 'fedora', 'rhel']: deps.extend(['popt', 'glibc', 'glibc-devel', 'libcap-ng', 'libcap', 'libcap-devel', 'elfutils-libelf', 'elfutils-libelf-devel', 'openssl-devel']) for package in deps: if not smg.check_installed(package) and not smg.install(package): self.cancel('%s is needed for the test to be run' % package) self.kernel_version = platform.uname()[2] self.iterations = self.params.get('runs', default=1) self.threads = self.params.get( 'cpus', default=2 * cpu.online_count()) self.location = self.params.get( 'url', default='https://github.com/torvalds/linux/archive' '/master.zip') self.config_path = os.path.join('/boot/config-', self.kernel_version) # Uncompress the kernel archive to the work directory tarball = self.fetch_asset("kernbench.zip", locations=[self.location], expire='1d') archive.extract(tarball, self.workdir)
def host(): logging.info("Setup monitor server on host") # Kill previous instances of the host load programs, if any _kill_host_programs(kill_stress_cmd, kill_monitor_cmd) # Cleanup previous log instances if os.path.isfile(monitor_log_file_server): os.remove(monitor_log_file_server) # Opening firewall ports on host process.run("iptables -F", ignore_status=True) # Run heartbeat on host process.run( server_setup_cmd % (monitor_dir, threshold, monitor_log_file_server, monitor_port), shell=True) if stress_setup_cmd is not None: logging.info("Build stress on host") # Uncompress and build stress on host process.run(stress_setup_cmd % stress_dir, shell=True) logging.info("Run stress on host") # stress_threads = 2 * n_cpus threads_host = 2 * cpu.online_count() # Run stress test on host process.run(stress_cmd % (stress_dir, threads_host), shell=True)
def run(test, params, env): """ vCPU offline/online test: 1) Launch a guest with many CPU. 2) Offline all CPUs except 0. 3) Online them again. """ host_cpu = cpu.online_count() cpu_range = range(host_cpu) cpu_list = "{}-{}".format(cpu_range[1], cpu_range[-1]) params["smp"] = params["vcpu_maxcpus"] = host_cpu params["start_vm"] = "yes" vm = env.get_vm(params['main_vm']) vm.create(params=params) vm.verify_alive() session = vm.wait_for_login() error_context.base_context("Offline CPUs: {}".format(cpu_list), logging.info) session.cmd("chcpu -d {}".format(cpu_list), timeout=len(cpu_range)) if not check_if_vm_vcpu_match(1, vm): test.fail("CPU quantity on guest mismatch after offline") logging.info("{} have been offline.".format(cpu_list)) error_context.context("Online CPUs: {}".format(cpu_list), logging.info) session.cmd("chcpu -e {}".format(cpu_list), timeout=len(cpu_range)) if not check_if_vm_vcpu_match(host_cpu, vm): test.fail("CPU quantity on guest mismatch after online again") logging.info("{} have been online.".format(cpu_list))
def setUp(self): self.test_file = self.params.get('tmp_file', default='/tmp/dummy') self.duration = self.params.get('duration', default='30') self.threads = self.params.get( 'threads', default=cpu.online_count()) self.size = self.params.get( 'memory_to_test', default=int(0.9 * memory.meminfo.MemFree.m)) smm = SoftwareManager() for package in ['gcc', 'libtool', 'autoconf', 'automake', 'make']: if not smm.check_installed(package) and not smm.install(package): self.cancel("Failed to install %s, which is needed for" "the test to be run" % package) if not os.path.exists(self.test_file): try: os.mknod(self.test_file) except OSError: self.cancel("Skipping test since test file creation failed") loc = ["https://github.com/stressapptest/" "stressapptest/archive/master.zip"] tarball = self.fetch_asset("stressapp.zip", locations=loc, expire='7d') archive.extract(tarball, self.workdir) self.sourcedir = os.path.join(self.workdir, 'stressapptest-master') os.chdir(self.sourcedir) process.run('./configure', shell=True) build.make(self.sourcedir)
def core(self): """ Tests the core in ppc64_cpu command. """ op1 = process.system_output( "ppc64_cpu --cores-present", shell=True).decode("utf-8").strip().split()[-1] op2 = cpu.online_count() / int(self.key) self.equality_check("Core", op1, ceil(op2))
def get_interrupts(string): """ Find the string and return a list of CPU stats for it """ int_op = genio.read_file("/proc/interrupts") for line in int_op.splitlines(): if string in line: line = line.split()[1: cpu.online_count() + 1] return line return []
def run_aio_tests(target): """Compile the source code then run aio tests.""" while True: path = yield with chcwd(path): LOG_JOB.debug("compile source code of QEMU") process.run("./configure") cpu_count = cpu.online_count() aio_path = "tests/test-aio" make_cmd = "make {aio_path} -j{cpu_count}".format( aio_path=aio_path, cpu_count=cpu_count) process.run(make_cmd) LOG_JOB.debug("run aio tests") result = process.run(aio_path) target.send(result.stdout_text)
def setUp(self): """ Verify : 1. It is Power system and platform is Power NV. 2. Cpupower tool is installed. """ if 'ppc' not in distro.detect().arch: self.cancel("Processor is not ppc64") if not os.path.exists('/sys/devices/system/cpu/cpu0/cpufreq'): self.cancel('CPUFREQ is supported only on Power NV') smm = SoftwareManager() detected_distro = distro.detect() if 'Ubuntu' in detected_distro.name: deps = ['linux-tools-common', 'linux-tools-%s' % platform.uname()[2]] elif detected_distro.name == "SuSE": deps = ['cpupower'] else: deps = ['kernel-tools'] for package in deps: if not smm.check_installed(package) and not smm.install(package): self.cancel('%s is needed for the test to be run' % package) fre_min = 0 fre_max = 0 freq_info = process.system_output( "cpupower frequency-info", shell=True).decode("utf-8") for line in str(freq_info).splitlines(): if re.search('hardware limits:', line, re.IGNORECASE): frq = line.split(":")[1] frq_init = frq.split('-')[0] frq_last = frq.split('-')[1] fre_min = float(frq_init.split('GHz')[0]) fre_max = float(frq_last.split('GHz')[0]) break threshold = (fre_max - fre_min) * (10 ** 6) self.threshold = int(self.params.get("threshold", default=threshold)) self.cpus = cpu.online_count() self.cpu_num = 0 self.max_freq = 0 self.quad_dict = {} self.max_freq_dict = {} self.quad_to_cpu_mapping()
def host_stress_event(self, event): """ Host Stress events :param event: event name """ for itr in range(self.host_iterations): if "cpu_freq_governor" in event: cpu.set_freq_governor() if hasattr( cpu, 'set_freq_governor') else cpu.set_cpufreq_governor() LOG.debug( "Current governor: %s", cpu.get_freq_governor() if hasattr(cpu, 'get_freq_governor') else cpu.get_cpufreq_governor()) time.sleep(self.event_sleep_time) elif "cpu_idle" in event: idlestate = cpu.get_idle_state() if hasattr( cpu, 'get_idle_state') else cpu.get_cpuidle_state() cpu.set_idle_state() if hasattr( cpu, 'set_idle_state') else cpu.set_cpuidle_state() time.sleep(self.event_sleep_time) cpu.set_idle_state(setstate=idlestate) if hasattr( cpu, 'set_idle_state') else cpu.set_cpuidle_state( setstate=idlestate) time.sleep(self.event_sleep_time) elif "cpuoffline" in event: online_count = cpu.online_count() if hasattr( cpu, 'online_count') else cpu.online_cpus_count() processor = self.host_cpu_list[random.randint( 0, online_count - 1)] cpu.offline(processor) time.sleep(self.event_sleep_time) cpu.online(processor) else: raise NotImplementedError time.sleep(self.itr_sleep_time)
def run(test, params, env): """ Check the TSC(time stamp counter) frequency of guest and host whether match or not 1) Test the vcpus' TSC of host by C the program 2) Copy the C code to the guest, complie and run it to get the vcpus' TSC of guest 3) Sleep sometimes and get the TSC of host and guest again 4) Compute the TSC frequency of host and guest 5) Compare the frequency deviation between host and guest with standard :param test: QEMU test object :param params: Dictionary with the test parameters. :param env: Dictionary with test environment. """ drift_threshold = float(params.get("drift_threshold")) interval = float(params.get("interval")) cpu_chk_cmd = params.get("cpu_chk_cmd") tsc_cmd_guest = params.get("tsc_cmd_guest", "./a.out") tsc_cmd_host = params.get("tsc_cmd_host", "./a.out") tsc_freq_path = os.path.join(data_dir.get_deps_dir(), 'timedrift/get_tsc.c') host_freq = 0 def get_tsc(machine="host", i=0): tsc_cmd = tsc_cmd_guest if tsc_cmd == "host": tsc_cmd = tsc_cmd_host cmd = "taskset %s %s" % (1 << i, tsc_cmd) if machine == "host": result = process.run(cmd, ignore_status=True) s, o = result.exit_status, result.stdout else: s, o = session.cmd_status_output(cmd) if s != 0: test.error("Fail to get tsc of host, ncpu: %d" % i) o = re.findall(r"(\d+)", o)[0] return float(o) vm = env.get_vm(params["main_vm"]) vm.verify_alive() session = vm.wait_for_login(timeout=int(params.get("login_timeout", 360))) if not os.path.exists(tsc_cmd_guest): process.run("gcc %s" % tsc_freq_path) ncpu = cpu.online_count() test.log.info("Interval is %s", interval) test.log.info("Determine the TSC frequency in the host") for i in range(ncpu): tsc1 = get_tsc("host", i) time.sleep(interval) tsc2 = get_tsc("host", i) delta = tsc2 - tsc1 test.log.info("Host TSC delta for cpu %s is %s", i, delta) if delta < 0: test.error("Host TSC for cpu %s warps %s" % (i, delta)) host_freq += delta / ncpu test.log.info("Average frequency of host's cpus: %s", host_freq) if session.cmd_status("test -x %s" % tsc_cmd_guest): vm.copy_files_to(tsc_freq_path, '/tmp/get_tsc.c') if session.cmd_status("gcc /tmp/get_tsc.c") != 0: test.error("Fail to compile program on guest") s, guest_ncpu = session.cmd_status_output(cpu_chk_cmd) if s != 0: test.error("Fail to get cpu number of guest") success = True for i in range(int(guest_ncpu)): tsc1 = get_tsc("guest", i) time.sleep(interval) tsc2 = get_tsc("guest", i) delta = tsc2 - tsc1 test.log.info("Guest TSC delta for vcpu %s is %s", i, delta) if delta < 0: test.log.error("Guest TSC for vcpu %s warps %s", i, delta) ratio = 100 * (delta - host_freq) / host_freq test.log.info("TSC drift ratio for vcpu %s is %s", i, ratio) if abs(ratio) > drift_threshold: test.log.error("TSC drift found for vcpu %s ratio %s", i, ratio) success = False if not success: test.fail("TSC drift found for the guest, please check the " "log for details") session.close()
def run(test, params, env): """ NIC option check test. :param test: QEMU test object :param params: Dictionary with the test parameters :param env: Dictionary with test environment. """ def test_netperf(): """ Netperf stress test for nic option. """ netperf_client_link = os.path.join(data_dir.get_deps_dir("netperf"), params.get("netperf_client_link")) client_path = params.get("client_path") n_client = utils_netperf.NetperfClient( vm.get_address(), client_path, netperf_source=netperf_client_link, client=params.get("shell_client"), port=params.get("shell_port"), username=params.get("username"), password=params.get("password"), prompt=params.get("shell_prompt"), linesep=params.get("shell_linesep", "\n").encode().decode('unicode_escape'), status_test_command=params.get("status_test_command", ""), compile_option=params.get("compile_option", "")) n_server = utils_netperf.NetperfServer( utils_net.get_host_ip_address(params), params.get("server_path", "/var/tmp"), netperf_source=os.path.join(data_dir.get_deps_dir("netperf"), params.get("netperf_server_link")), password=params.get("hostpassword"), compile_option=params.get("compile_option", "")) try: n_server.start() # Run netperf with message size defined in range. netperf_test_duration = int( params.get("netperf_test_duration", 180)) netperf_para_sess = params.get("netperf_para_sessions", "1") test_protocols = params.get("test_protocols", "TCP_STREAM") netperf_cmd_prefix = params.get("netperf_cmd_prefix", "") netperf_output_unit = params.get("netperf_output_unit") netperf_package_sizes = params.get("netperf_sizes") test_option = params.get("test_option", "") test_option += " -l %s" % netperf_test_duration if params.get("netperf_remote_cpu") == "yes": test_option += " -C" if params.get("netperf_local_cpu") == "yes": test_option += " -c" if netperf_output_unit in "GMKgmk": test_option += " -f %s" % netperf_output_unit start_time = time.time() stop_time = start_time + netperf_test_duration num = 0 for protocol in test_protocols.split(): error_context.context("Testing %s protocol" % protocol, logging.info) t_option = "%s -t %s" % (test_option, protocol) n_client.bg_start(utils_net.get_host_ip_address(params), t_option, netperf_para_sess, netperf_cmd_prefix, package_sizes=netperf_package_sizes) if utils_misc.wait_for(n_client.is_netperf_running, 10, 0, 1, "Wait netperf test start"): logging.info("Netperf test start successfully.") else: test.error("Can not start netperf client.") num += 1 # here when set a run flag, when other case call this case as a # subprocess backgroundly,can set this run flag to False to stop # the stress test. env["netperf_run"] = True netperf_test_duration = stop_time - time.time() utils_misc.wait_for( lambda: not n_client.is_netperf_running(), netperf_test_duration, 0, 5, "Wait netperf test finish %ss" % netperf_test_duration) time.sleep(5) finally: n_server.stop() n_server.package.env_cleanup(True) n_client.package.env_cleanup(True) def test_ping(): """ Ping test for nic option. """ package_sizes = params.objects("ping_sizes") if params["os_type"] == "windows": ifname = utils_net.get_windows_nic_attribute( session=session, key="netenabled", value=True, target="netconnectionID") else: ifname = utils_net.get_linux_ifname(session, vm.get_mac_address()) dest = utils_net.get_host_ip_address(params) for size in package_sizes: error_context.context( "Test ping from '%s' to host '%s' on guest '%s'" " with package size %s. " % (ifname, dest, vm.name, size), logging.info) status, output = utils_net.ping(dest=dest, count=10, packetsize=size, session=session, timeout=30) if status: test.fail("%s ping %s unexpected, output %s" % (vm.name, dest, output)) if params["os_type"] == "windows": # windows guest get loss=0 when ping failed sometime, # need further check loss = utils_test.get_loss_ratio(output) if loss or "TTL" in output: pass else: test.fail("Guest ping test hit unexpected loss, " "error_info: %s" % output) check_type = params.get("check_type") smp_value = params.get_numeric("smp") or params.get_numeric("vcpu_maxcpus") if cpu.online_count() < 2 * smp_value: test.cancel("The number of smp counts in this host is not big enough") vm = env.get_vm(params["main_vm"]) vm.verify_alive() session = vm.wait_for_serial_login() try: if params["os_type"] == "windows": error_context.context("Verify if netkvm.sys is enabled in guest", logging.info) session = utils_test.qemu.windrv_check_running_verifier( session, vm, test, "netkvm") func_name = {"ping": test_ping, "netperf": test_netperf} func_name[check_type]() finally: session.close()
def run(test, params, env): """ ple test: 1) Check if ple is enabled on host, if not, enable it 2) Boot guest and run unixbench inside guest 3) Record benchmark scores and shutdown guest 4) Disable ple on host 5) Boot guest and run unixbench inside guest again 6) Compare benchmark scores with step 3) 7) Restore env, set ple back :param test: QEMU test object :param params: Dictionary with the test parameters :param env: Dictionary with test environment. """ def reload_module(value): """ Reload module """ process.system("rmmod %s" % module) cmd = "modprobe %s %s=%s" % (module, mod_param, value) process.system(cmd) def run_unixbench(cmd): """ Run unixbench inside guest, return benchmark scores """ error_context.context("Run unixbench inside guest", logging.info) output = session.cmd_output_safe(cmd, timeout=4800) scores = re.findall(r"System Benchmarks Index Score\s+(\d+\.?\d+)", output) return [float(i) for i in scores] module = params["module_name"] mod_param = params["mod_param"] read_cmd = "cat /sys/module/%s/parameters/%s" % (module, mod_param) origin_ple = process.getoutput(read_cmd) error_context.context("Enable ple on host if it's disabled", logging.info) if origin_ple == 0: reload_module(params["ple_value"]) host_cpu_count = cpu.online_count() params["smp"] = host_cpu_count params["vcpu_maxcpus"] = host_cpu_count params["start_vm"] = "yes" env_process.preprocess_vm(test, params, env, params["main_vm"]) vm = env.get_vm(params["main_vm"]) vm.verify_alive() session = vm.wait_for_login() session.cmd(params["get_unixbench"]) try: cmd = params["run_unixbench"] scores_on = run_unixbench(cmd) logging.info("Unixbench scores are %s when ple is on" % scores_on) vm.destroy() error_context.context("Disable ple on host", logging.info) reload_module(0) vm.create(params=params) session = vm.wait_for_login() scores_off = run_unixbench(cmd) logging.info("Unixbench scores are %s when ple is off" % scores_off) scores_off = [x*0.96 for x in scores_off] if scores_on[0] < scores_off[0] or scores_on[1] < scores_off[1]: test.fail("Scores is much lower when ple is on than off") finally: session.cmd_output_safe("rm -rf %s" % params["unixbench_dir"]) session.close() vm.destroy() reload_module(origin_ple)
def run(test, params, env): """ NIC option check test. :param test: QEMU test object :param params: Dictionary with the test parameters :param env: Dictionary with test environment. """ def test_netperf(): """ Netperf stress test for nic option. """ netperf_client_link = os.path.join(data_dir.get_deps_dir("netperf"), params.get("netperf_client_link")) client_path = params.get("client_path") n_client = utils_netperf.NetperfClient( vm.get_address(), client_path, netperf_source=netperf_client_link, client=params.get("shell_client"), port=params.get("shell_port"), username=params.get("username"), password=params.get("password"), prompt=params.get("shell_prompt"), linesep=params.get("shell_linesep", "\n").encode().decode('unicode_escape'), status_test_command=params.get("status_test_command", ""), compile_option=params.get("compile_option", "")) n_server = utils_netperf.NetperfServer( utils_net.get_host_ip_address(params), params.get("server_path", "/var/tmp"), netperf_source=os.path.join(data_dir.get_deps_dir("netperf"), params.get("netperf_server_link")), password=params.get("hostpassword"), compile_option=params.get("compile_option", "")) try: n_server.start() # Run netperf with message size defined in range. test_duration = int(params.get("netperf_test_duration", 180)) deviation_time = params.get_numeric("deviation_time") netperf_para_sess = params.get("netperf_para_sessions", "1") test_protocols = params.get("test_protocols", "TCP_STREAM") netperf_cmd_prefix = params.get("netperf_cmd_prefix", "") netperf_output_unit = params.get("netperf_output_unit") netperf_package_sizes = params.get("netperf_sizes") test_option = params.get("test_option", "") test_option += " -l %s" % test_duration if params.get("netperf_remote_cpu") == "yes": test_option += " -C" if params.get("netperf_local_cpu") == "yes": test_option += " -c" if netperf_output_unit in "GMKgmk": test_option += " -f %s" % netperf_output_unit num = 0 for protocol in test_protocols.split(): error_context.context("Testing %s protocol" % protocol, logging.info) t_option = "%s -t %s" % (test_option, protocol) n_client.bg_start(utils_net.get_host_ip_address(params), t_option, netperf_para_sess, netperf_cmd_prefix, package_sizes=netperf_package_sizes) if utils_misc.wait_for(n_client.is_netperf_running, 10, 0, 3, "Wait netperf test start"): logging.info("Netperf test start successfully.") else: test.error("Can not start netperf client.") num += 1 start_time = time.time() # here when set a run flag, when other case call this case as a # subprocess backgroundly,can set this run flag to False to stop # the stress test. env["netperf_run"] = True duration = time.time() - start_time max_run_time = test_duration + deviation_time while duration < max_run_time: time.sleep(10) duration = time.time() - start_time status = n_client.is_netperf_running() if not status and duration < test_duration - 10: test.fail("netperf terminated unexpectedly") logging.info("Wait netperf test finish %ss", duration) if n_client.is_netperf_running(): test.fail("netperf still running, netperf hangs") else: logging.info("netperf runs successfully") finally: n_server.stop() n_server.cleanup(True) n_client.cleanup(True) def test_ping(): """ Ping test for nic option. """ package_sizes = params.objects("ping_sizes") guest_ip = vm.get_address() for size in package_sizes: error_context.context( "From host ping to '%s' with guest '%s'" " with package size %s. " % (vm.name, guest_ip, size), logging.info) status, output = utils_net.ping(guest_ip, count=10, packetsize=size, timeout=30) if status != 0: test.fail("host ping %s unexpected, output %s" % (guest_ip, output)) check_type = params.get("check_type") smp_value = params.get_numeric("smp") or params.get_numeric("vcpu_maxcpus") if cpu.online_count() < 2 * smp_value: test.cancel("The number of smp counts in this host is not big enough") vm = env.get_vm(params["main_vm"]) vm.verify_alive() session = vm.wait_for_serial_login() try: match_string = "unable to start vhost net" output = vm.process.get_output() if match_string in output: test.fail("Qemu output error info: %s" % output) if params["os_type"] == "windows": driver_verifier = params["driver_verifier"] error_context.context("Verify if netkvm.sys is enabled in guest", logging.info) session = utils_test.qemu.windrv_check_running_verifier( session, vm, test, driver_verifier) func_name = {"ping": test_ping, "netperf": test_netperf} func_name[check_type]() finally: session.close()
def run(test, params, env): """ Test hotplug maximum vCPU device. 1) Launch a guest without vCPU device. 2) Hotplug all vCPU devices and check successfully or not. (qemu side) 3) Check if the number of CPUs in guest changes accordingly. (guest side) 4) Reboot guest. 5) Hotunplug all vCPU devices and check successfully or not. (qemu side) :param test: QEMU test object. :param params: Dictionary with the test parameters. :param env: Dictionary with test environment. """ os_type = params["os_type"] machine_type = params["machine_type"] reboot_timeout = params.get_numeric("reboot_timeout") mismatch_text = "Actual number of guest CPUs is not equal to the expected" not_equal_text = "CPU quantity mismatched! Guest got %s but expected is %s" # Many vCPUs will be plugged, it takes some time to bring them online. verify_wait_timeout = params.get_numeric("verify_wait_timeout", 300) qemu_binary = utils_misc.get_qemu_binary(params) machine_info = utils_qemu.get_machines_info(qemu_binary)[machine_type] machine_info = re.search(r'\(alias of (\S+)\)', machine_info) current_machine = machine_info.group(1) if machine_info else machine_type supported_maxcpus = (params.get_numeric("vcpu_maxcpus") or utils_qemu.get_maxcpus_hard_limit( qemu_binary, current_machine)) if not params.get_boolean("allow_pcpu_overcommit"): supported_maxcpus = min(supported_maxcpus, cpu.online_count()) logging.info("Define the CPU topology of guest") vcpu_devices = [] if (cpu.get_vendor() == "amd" and params.get_numeric("vcpu_threads") != 1): test.cancel("AMD cpu does not support multi threads") elif machine_type.startswith("pseries"): host_kernel_ver = uname()[2].split("-")[0] if params.get_numeric("vcpu_threads") == 8: supported_maxcpus -= divmod(supported_maxcpus, 8)[1] vcpu_devices = [ "vcpu%d" % c for c in range(1, supported_maxcpus // 8) ] # The maximum value of vcpu_id in 'linux-3.x' is 2048, so # (vcpu_id * ms->smp.threads / spapr->vsmt) <= 256, need to adjust it elif (supported_maxcpus > 256 and host_kernel_ver not in VersionInterval("[4, )")): supported_maxcpus = 256 vcpu_devices = vcpu_devices or [ "vcpu%d" % vcpu for vcpu in range(1, supported_maxcpus) ] params["vcpu_maxcpus"] = str(supported_maxcpus) params["vcpu_devices"] = " ".join(vcpu_devices) params["start_vm"] = "yes" vm = env.get_vm(params["main_vm"]) vm.create(params=params) vm.verify_alive() session = vm.wait_for_login() cpuinfo = vm.cpuinfo smp = cpuinfo.smp vcpus_count = vm.params.get_numeric("vcpus_count") error_context.context("Hotplug all vCPU devices", logging.info) for vcpu_device in vcpu_devices: vm.hotplug_vcpu_device(vcpu_device) error_context.context("Check Number of vCPU in guest", logging.info) if not utils_misc.wait_for(lambda: vm.get_cpu_count() == supported_maxcpus, verify_wait_timeout, first=5, step=10): logging.error(not_equal_text, vm.get_cpu_count(), supported_maxcpus) test.fail(mismatch_text) logging.info("CPU quantity is as expected: %s", supported_maxcpus) error_context.context("Check CPU topology of guest", logging.info) if not cpu_utils.check_guest_cpu_topology(session, os_type, cpuinfo): test.fail("CPU topology of guest is not as expected.") session = vm.reboot(session, timeout=reboot_timeout) if not cpu_utils.check_guest_cpu_topology(session, os_type, cpuinfo): test.fail("CPU topology of guest is not as expected after reboot.") error_context.context("Hotunplug all vCPU devices", logging.info) for vcpu_device in reversed(vcpu_devices): vm.hotunplug_vcpu_device(vcpu_device, 10 * vcpus_count) if not utils_misc.wait_for(lambda: vm.get_cpu_count() == smp, verify_wait_timeout, first=5, step=10): logging.error(not_equal_text, vm.get_cpu_count(), smp) test.fail(mismatch_text) logging.info("CPU quantity is as expected after hotunplug: %s", smp) session.close()
def run(test, params, env): """ Check guest gets correct vcpu num, cpu cores, processors, sockets, siblings 1) Boot guest with options: -smp n,cores=x,threads=y,sockets=z... 2) Check cpu topology :param test: QEMU test object. :param params: Dictionary with test parameters. :param env: Dictionary with the test environment. """ def check(p_name, exp, check_cmd): """ Check the cpu property inside guest :param p_name: Property name :param exp: The expect value :param check_cmd: The param to get check command """ res = session.cmd_output(params[check_cmd]).strip() if int(res) != int(exp): test.fail('The vcpu %s number inside guest is %s,' ' while it is set to %s' % (p_name, res, exp)) vm_name = params['main_vm'] os_type = params['os_type'] vcpu_threads_list = [1, 2] if params['machine_type'] == 'pseries': vcpu_threads_list = [1, 2, 4, 8] host_cpu = cpu.online_count() params['vcpu_cores'] = vcpu_cores = random.randint(1, min(6, host_cpu//2)) for vcpu_threads in vcpu_threads_list: vcpu_sockets = min(max(host_cpu // (vcpu_cores * vcpu_threads), 1), random.randint(1, 6)) vcpu_sockets = 2 if (os_type == 'Windows' and vcpu_sockets > 2) else vcpu_sockets params['vcpu_sockets'] = vcpu_sockets params['vcpu_threads'] = vcpu_threads params['smp'] = params['vcpu_maxcpus'] = (vcpu_cores * vcpu_threads * vcpu_sockets) params['start_vm'] = 'yes' try: env_process.preprocess_vm(test, params, env, vm_name) except Exception as e: # The cpu topology sometimes will be changed by # qemu_vm.VM.make_create_command, and thus cause qemu vm fail to # start, which is expected; Modify the value and restart vm in # this case, and verify cpu topology inside guest after that if 'qemu-kvm: cpu topology' in str(e): sockets = int(re.findall(r'sockets\s+\((\d)\)', str(e))[0]) threads = int(re.findall(r'threads\s+\((\d)\)', str(e))[0]) cores = int(re.findall(r'cores\s+\((\d)\)', str(e))[0]) params['smp'] = params['vcpu_maxcpus'] = (sockets * threads * cores) env_process.preprocess_vm(test, params, env, vm_name) else: raise vm = env.get_vm(vm_name) session = vm.wait_for_login() check_guest_cpu_topology(session, os_type, vm.cpuinfo) if params.get('check_siblings_cmd'): check('sibling', vcpu_threads * vcpu_cores, 'check_siblings_cmd') vm.destroy()
def run(test, params, env): """ Run kernbench for performance testing. 1) Set up testing environment. 2) Get a kernel code. 3) Make the kernel with kernbench -M or time make -j 2*smp :param test: QEMU test object :param params: Dictionary with the test parameters :param env: Dictionary with test environment. """ def download_if_not_exists(): if not os.path.exists(file_name): cmd = "wget -t 10 -c -P %s %s" % (tmp_dir, file_link) process.system(cmd) def cmd_status_output(cmd, timeout=360): s = 0 o = "" if "guest" in test_type: (s, o) = session.cmd_status_output(cmd, timeout=timeout) else: cmd_result = process.run(cmd, ignore_status=True, shell=True) (s, o) = cmd_result.exit_status, cmd_result.stdout return (s, o) def check_ept(): output = process.system_output("grep 'flags' /proc/cpuinfo") flags = output.splitlines()[0].split(':')[1].split() need_ept = params.get("need_ept", "no") if 'ept' not in flags and "yes" in need_ept: test.cancel("This test requires a host that supports EPT") elif 'ept' in flags and "no" in need_ept: cmd = "modprobe -r kvm_intel && modprobe kvm_intel ept=0" process.system(cmd, timeout=100, shell=True) elif 'ept' in flags and "yes" in need_ept: cmd = "modprobe -r kvm_intel && modprobe kvm_intel ept=1" process.system(cmd, timeout=100, shell=True) def install_gcc(): logging.info("Update gcc to request version....") cmd = "rpm -q gcc" cpp_link = params.get("cpp_link") gcc_link = params.get("gcc_link") libgomp_link = params.get("libgomp_link") libgcc_link = params.get("libgcc_link") (s, o) = cmd_status_output(cmd) if s: cmd = "rpm -ivh %s --nodeps; rpm -ivh %s --nodeps; rpm -ivh %s"\ " --nodeps; rpm -ivh %s --nodeps" % (libgomp_link, libgcc_link, cpp_link, gcc_link) else: gcc = o.splitlines()[0].strip() if gcc in gcc_link: cmd = "rpm -e %s && rpm -ivh %s" % (gcc, gcc_link) else: cmd = "rpm -ivh %s --nodeps; rpm -ivh %s --nodeps; rpm -ivh"\ " %s --nodeps; rpm -ivh %s --nodeps" % (libgomp_link, libgcc_link, cpp_link, gcc_link) (s, o) = cmd_status_output(cmd) if s: logging.debug("Fail to install gcc.output:%s" % o) def record_result(result): re_result = params.get("re_result") (m_value, s_value) = re.findall(re_result, result)[0] s_value = float(m_value) * 60 + float(s_value) shortname = params.get("shortname") result_str = "%s: %ss\n" % (shortname, s_value) result_file = params.get("result_file") f1 = open(result_file, "a+") result = f1.read() result += result_str f1.write(result_str) f1.close() open(os.path.basename(result_file), 'w').write(result) logging.info("Test result got from %s:\n%s" % (result_file, result)) test_type = params.get("test_type") guest_thp_cmd = params.get("guest_thp_cmd") cmd_timeout = int(params.get("cmd_timeout", 1200)) tmp_dir = params.get("tmp_dir", "/tmp/kernbench/") check_ept() vm_name = params.get("main_vm", "vm1") cpu_multiplier = int(params.get("cpu_multiplier", 2)) session = None if "guest" in test_type: env_process.preprocess_vm(test, params, env, vm_name) vm = env.get_vm(params["main_vm"]) vm.verify_alive() session = vm.wait_for_login( timeout=int(params.get("login_timeout", 360))) # Create tmp folder and download files if need. if not os.path.exists(tmp_dir): process.system("mkdir %s" % tmp_dir) files = params.get("files_need").split() for file in files: file_link = params.get("%s_link" % file) file_name = os.path.join(tmp_dir, os.path.basename(file_link)) download_if_not_exists() if "guest" in test_type: logging.info("test in guest") vm.copy_files_to(tmp_dir, os.path.dirname(tmp_dir)) if guest_thp_cmd is not None: session.cmd_output(guest_thp_cmd) try: if params.get("update_gcc") and params.get("update_gcc") == "yes": install_gcc() pre_cmd = params.get("pre_cmd") (s, o) = cmd_status_output(pre_cmd, timeout=cmd_timeout) if s: test.error("Fail command:%s\nOutput: %s" % (pre_cmd, o)) if "guest" in test_type: cpu_num = params.get("smp") else: cpu_num = cpu.online_count() test_cmd = params.get("test_cmd") % (int(cpu_num) * cpu_multiplier) logging.info("Start making the kernel ....") (s, o) = cmd_status_output(test_cmd, timeout=cmd_timeout) if s: test.error("Fail command:%s\n Output:%s" % (test_cmd, o)) else: logging.info("Output for command %s is:\n %s" % (test_cmd, o)) record_result(o) finally: if params.get("post_cmd"): cmd_status_output(params.get("post_cmd"), timeout=cmd_timeout) if session: session.close()