-
Notifications
You must be signed in to change notification settings - Fork 139
/
ntttcp.py
185 lines (171 loc) · 7.09 KB
/
ntttcp.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
import logging, os, glob, re, commands
from autotest.client.shared import error
from autotest.client.shared import utils
from virttest import utils_misc, utils_test, remote
from virttest import aexpect
_receiver_ready = False
def run_ntttcp(test, params, env):
"""
Run NTttcp on Windows guest
1) Install NTttcp in server/client side by Autoit
2) Start NTttcp in server/client side
3) Get test results
@param test: kvm test object
@param params: Dictionary with the test parameters
@param env: Dictionary with test environment.
"""
login_timeout = int(params.get("login_timeout", 360))
timeout = int(params.get("timeout"))
results_path = os.path.join(test.resultsdir,
'raw_output_%s' % test.iteration)
platform = "x86"
if params.get("platform") == "64":
platform = "x64"
buffers = params.get("buffers").split()
buf_num = params.get("buf_num", 200000)
session_num = params.get("session_num")
vm_sender = env.get_vm(params["main_vm"])
vm_sender.verify_alive()
vm_receiver = None
receiver_addr = params.get("receiver_address")
logging.debug(utils.system("numactl --hardware", ignore_status=True))
logging.debug(utils.system("numactl --show", ignore_status=True))
# pin guest vcpus/memory/vhost threads to last numa node of host by default
if params.get('numa_node'):
numa_node = int(params.get('numa_node'))
node = utils_misc.NumaNode(numa_node)
utils_test.pin_vm_threads(vm_sender, node)
if not receiver_addr:
vm_receiver = env.get_vm("vm2")
vm_receiver.verify_alive()
try:
sess = None
sess = vm_receiver.wait_for_login(timeout=login_timeout)
receiver_addr = vm_receiver.get_address()
if not receiver_addr:
raise error.TestError("Can't get receiver(%s) ip address" %
vm_sender.name)
if params.get('numa_node'):
utils_test.pin_vm_threads(vm_receiver, node)
finally:
if sess:
sess.close()
@error.context_aware
def install_ntttcp(session):
""" Install ntttcp through a remote session """
logging.info("Installing NTttcp ...")
try:
# Don't install ntttcp if it's already installed
error.context("NTttcp directory already exists")
session.cmd(params.get("check_ntttcp_cmd"))
except aexpect.ShellCmdError:
ntttcp_install_cmd = params.get("ntttcp_install_cmd")
error.context("Installing NTttcp on guest")
session.cmd(ntttcp_install_cmd % (platform, platform), timeout=200)
def receiver():
""" Receive side """
logging.info("Starting receiver process on %s", receiver_addr)
if vm_receiver:
session = vm_receiver.wait_for_login(timeout=login_timeout)
else:
username = params.get("username", "")
password = params.get("password", "")
prompt = params.get("shell_prompt", "[\#\$]")
linesep = eval("'%s'" % params.get("shell_linesep", r"\n"))
client = params.get("shell_client")
port = int(params.get("shell_port"))
log_filename = ("session-%s-%s.log" % (receiver_addr,
utils_misc.generate_random_string(4)))
session = remote.remote_login(client, receiver_addr, port,
username, password, prompt,
linesep, log_filename, timeout)
session.set_status_test_command("echo %errorlevel%")
install_ntttcp(session)
ntttcp_receiver_cmd = params.get("ntttcp_receiver_cmd")
global _receiver_ready
f = open(results_path + ".receiver", 'a')
for b in buffers:
utils_misc.wait_for(lambda: not _wait(), timeout)
_receiver_ready = True
rbuf = params.get("fixed_rbuf", b)
cmd = ntttcp_receiver_cmd % (session_num, receiver_addr, rbuf, buf_num)
r = session.cmd_output(cmd, timeout=timeout,
print_func=logging.debug)
f.write("Send buffer size: %s\n%s\n%s" % (b, cmd, r))
f.close()
session.close()
def _wait():
""" Check if receiver is ready """
global _receiver_ready
if _receiver_ready:
return _receiver_ready
return False
def sender():
""" Send side """
logging.info("Sarting sender process ...")
session = vm_sender.wait_for_login(timeout=login_timeout)
install_ntttcp(session)
ntttcp_sender_cmd = params.get("ntttcp_sender_cmd")
f = open(results_path + ".sender", 'a')
try:
global _receiver_ready
for b in buffers:
cmd = ntttcp_sender_cmd % (session_num, receiver_addr, b, buf_num)
# Wait until receiver ready
utils_misc.wait_for(_wait, timeout)
r = session.cmd_output(cmd, timeout=timeout,
print_func=logging.debug)
_receiver_ready = False
f.write("Send buffer size: %s\n%s\n%s" % (b, cmd, r))
finally:
f.close()
session.close()
def parse_file(resultfile):
""" Parse raw result files and generate files with standard format """
fileobj = open(resultfile, "r")
lst = []
found = False
for line in fileobj.readlines():
o = re.findall("Send buffer size: (\d+)", line)
if o:
bfr = o[0]
if "Total Throughput(Mbit/s)" in line:
found = True
if found:
fields = line.split()
if len(fields) == 0:
continue
try:
[float(i) for i in fields]
lst.append([bfr, fields[-1]])
except ValueError:
continue
found = False
return lst
try:
bg = utils.InterruptedThread(receiver, ())
bg.start()
if bg.isAlive():
sender()
bg.join(suppress_exception=True)
else:
raise error.TestError("Can't start backgroud receiver thread")
finally:
for i in glob.glob("%s.receiver" % results_path):
f = open("%s.RHS" % results_path, "w")
raw = " buf(k)| throughput(Mbit/s)"
logging.info(raw)
f.write("#ver# %s\n#ver# host kernel: %s\n" %
(commands.getoutput("rpm -q qemu-kvm"), os.uname()[2]))
desc = """#desc# The tests are sessions of "NTttcp", send buf number is %s. 'throughput' was taken from ntttcp's report.
#desc# How to read the results:
#desc# - The Throughput is measured in Mbit/sec.
#desc#
""" % (buf_num)
f.write(desc)
f.write(raw + "\n")
for j in parse_file(i):
raw = "%8s| %8s" % (j[0], j[1])
logging.info(raw)
f.write(raw + "\n")
f.close()