def invokeClients(self, host):
# Run synexec master
proc, port = libsynexec.start_master_on_controller("/bin/sh /root/synexec_cmd", self.jobid, self.numclients)
# After all the servers have booted, set up synexec slave in each of the client VMs
for i in range(0, self.numclients):
# Write a file containing the apachebench command, pointing it at the relevant server VM
target = self.servervms[i].getIP()
self.clientvms[i].execguest("echo '%s' > /root/synexec_cmd" % (self.abCmd % target))
# Wait for the synexec master to tell this VM to run the apachebench command
libsynexec.start_slave(self.clientvms[i], self.jobid, port)
# Wait for jobs to complete
proc.wait()
# Fetch results from slaves
for i in range (0, self.numclients):
logFileRemote = "/root/ab.log"
logFileLocal = "%s/ab-%d.log" % (xenrt.TEC().getLogdir(), i)
sftp = self.clientvms[i].sftpClient()
sftp.copyFrom(logFileRemote, logFileLocal)
# Fetch log from master
results = libsynexec.get_master_log_on_controller(self.jobid)
self.log("synexec_master", "%s" % results)
def runPhase(self, count, op):
for blocksize in self.blocksizes:
# TODO we don't support pre-defined access patterns with 'latency', only integer block sizes
blocksize = int(blocksize)
# Run synexec master
proc, port = libsynexec.start_master_on_controller(self.runPhasePrepareCommand(blocksize, op),
self.jobid, len(self.vm))
for vm in self.vm:
libsynexec.start_slave(vm, self.jobid, port)
proc.wait()
# Fetch results from slaves
for vm in self.vm:
for j in range(self.vbds_per_vm):
results = vm.execguest("cat /root/out-%s" % chr(ord('b') + j))
for line in results.splitlines():
# Log format: Operation(r,w) iteration, blocksize, diskname, VM number on that SR, VBD number, number of bytes processed
self.log("slave", "%s %d %d %s %s %d %s" %
(op, count + 1, blocksize, vm.getName().split("-")[0], vm.getName().split("-")[1], j, line))
# Fetch log from master
results = libsynexec.get_master_log_on_controller(self.jobid)
for line in results.splitlines():
self.log("master", "%d %s" % (blocksize, line))
def runPhase(self, count, op):
for blocksize in self.blocksizes:
# TODO we don't support pre-defined access patterns with 'latency', only integer block sizes
blocksize = int(blocksize)
# Run synexec master
proc, port = libsynexec.start_master_on_controller(
self.runPhasePrepareCommand(blocksize, op), self.jobid,
len(self.vm))
for vm in self.vm:
libsynexec.start_slave(vm, self.jobid, port)
proc.wait()
# Fetch results from slaves
for vm in self.vm:
for j in range(self.vbds_per_vm):
results = vm.execguest("cat /root/out-%s" %
chr(ord('b') + j))
for line in results.splitlines():
# Log format: Operation(r,w) iteration, blocksize, diskname, VM number on that SR, VBD number, number of bytes processed
self.log(
"slave", "%s %d %d %s %s %d %s" %
(op,
count + 1, blocksize, vm.getName().split("-")[0],
vm.getName().split("-")[1], j, line))
# Fetch log from master
results = libsynexec.get_master_log_on_controller(self.jobid)
for line in results.splitlines():
self.log("master", "%d %s" % (blocksize, line))
def run(self, arglist=None):
self.changeNrDom0vcpus(self.host, self.dom0vcpus)
self.loadKernelModule()
self.host.execdom0("iptables -F")
guests = self.host.guests.values()
if self.isNameinGuests(guests, "vm00"):
# reuse any existing vms
self.vm = guests
self.rvms = len(self.vm)
self.vbds = len(self.vm) * 2
else:
# Install 'vm00'
xenrt.TEC().progress("Installing VM zero")
self.vm.append(xenrt.lib.xenserver.guest.createVM(\
host=self.host,
guestname="vm00",
distro=self.distro,
arch=self.arch,
vifs=xenrt.lib.xenserver.Guest.DEFAULT,
disks=[ self.edisk ]))
self.rvms += 1
self.vbds += 2
# Copy bins to 'vm00'
sftp = self.vm[0].sftpClient()
sftp.copyTo("/home/xenrtd/felipef/latency", "/root/latency")
libsynexec.initialise_slave(self.vm[0])
# Copy bins to dom0
sftp = self.host.sftpClient()
libsynexec.initialise_master_in_dom0(self.host)
# Populate the extra disk
if (self.writefirst == "true"):
self.vm[0].execguest("dd if=/dev/zero of=/dev/xvdb bs=1M oflag=direct || true")
if len(self.vm) > self.vms:
# Shutdown unnecessary VMs
for i in range(self.vms, len(self.vm)):
self.backendDetach(self.vm[i]) #must detach any out-of-xapi devices before shutdown
self.shutdown_vm(self.vm[i])
if len(self.vm) < self.vms:
# Shutdown VM for cloning
self.backendDetach(self.vm[0]) #must detach any out-of-xapi devices before shutdown
self.shutdown_vm(self.vm[0])
# Install more VMs as appropriate
for i in range(len(self.vm), self.vms):
xenrt.TEC().progress("Installing VM %d" % i)
# Copies original VM (much quicker than installing another one)
cloned_vm = self.vm[0].copyVM(name="vm%02d" % i)
self.vm.append(cloned_vm)
self.host.addGuest(cloned_vm)
self.vm[i].start()
# Populate the extra disk
if (self.writefirst == "true"):
self.vm[i].execguest("dd if=/dev/zero of=/dev/xvdb bs=1M oflag=direct || true")
# At this point, we added one VM and plugged two more VBDs to the host
self.rvms += 1
self.vbds += 2
# Make sure all VMs are running and have synexec on
for i in range(0, self.vms):
self.start_vm(self.vm[i])
self.backendAttach(self.vm[i])
libsynexec.start_slave(self.vm[i], self.jobid)
# Change scheduler of the SRs where the VMs' VBDs are on
for i in range(0, self.vms):
sr_uuid = self.getSRofGuest(self.vm[i], self.userdevice)
self.changeDiskScheduler(self.host, sr_uuid, self.scheduler)
# Run synexec master
libsynexec.start_master_in_dom0(self.host, self.latcmd, self.jobid, self.vms)
# Fetch results from slaves
for i in range (0, self.vms):
results = libsynexec.get_slave_log(self.vm[i])
for line in results.splitlines():
self.log("concurrent", "%d %d" % (i, int(line)))
# Fetch log from master
results = libsynexec.get_master_log(self.host)
self.log("synexec_master", "%s" % results)
def runIperf(self,
origin,
origindev,
dest,
destdev,
interval=1,
duration=30,
threads=1,
protocol="tcp"):
prot_switch = None
if protocol == "tcp": prot_switch = ""
elif protocol == "udp": prot_switch = "-u"
else: raise xenrt.XRTError("unknown protocol %s" % (protocol, ))
dest_endpoints = self.endpoints_of(dest)
origin_endpoints = self.endpoints_of(origin)
synexec_session = randrange(1000000000)
iperf_in_file = "/tmp/iperf.in.%s" % (synexec_session, )
iperf_out_file = "/tmp/iperf.out.%s" % (synexec_session, )
if dest.windows:
raise Exception("Windows endpoint not supported yet")
else:
# 1. start iperf servers in each vm in endpoint1s + endpoint1
for d in dest_endpoints:
# Start server
d.execcmd(
"nohup iperf %s -s 0<&- &>/dev/null &" %
(prot_switch, )) # should be implemented in startIperf()
# 1.5. initialise synexec master in endpoint0
libsynexec.initialise_master_in_guest(origin)
# 2. start synexec slave in each vm in endpoint0s + endpoint0
for i in range(len(origin_endpoints)):
o = origin_endpoints[i]
d = dest_endpoints[i]
destIP = self.getIP(d, destdev)
libsynexec.start_slave(o, synexec_session)
o.execcmd("echo %s > %s" % (destIP, iperf_in_file))
# 3. create synexec master script in endpoint 0 to run iperf -c in each slave
master_script = """/bin/sh :CONF:
#!/bin/sh
DEST_IP=$(cat "%s")
iperf %s -c ${DEST_IP} -i %d -t %d -f m -P %d >%s 2>&1
""" % (iperf_in_file, prot_switch, interval, duration, threads, iperf_out_file)
self.log(None, "synexec_master_script=%s" % (master_script, ))
if self.dopause.lower() == "on" or (xenrt.TEC().lookup(
"PAUSE_AT_MASTER_ON_PHASE", "None") in self.getPhase()):
self.pause('paused before running synexec_master'
) # pause the tc and wait for user assistance
# 4. start synexec master in endpoint0
# 5. wait for synexec master to finish (=all synexec slaves finished iperf -c)
master_out = libsynexec.start_master_in_guest(
origin, master_script, synexec_session, len(origin_endpoints))
self.log(None, master_out)
# 6. kill iperf servers in each vm in endpoints1s + endpoint1
for d in dest_endpoints:
# Kill server
d.execcmd("killall iperf || true")
d.execcmd("killall -9 iperf || true")
for o in origin_endpoints:
libsynexec.kill_slave(o)
# 7. collect the iperf -c output in each endpoint0s + endpoint0
output = []
for o in origin_endpoints:
iperf_out = o.execcmd("cat %s" % (iperf_out_file, ))
self.log(
None, "collect results: endpoint %s: %s=%s" %
(o, iperf_out_file, iperf_out))
output.append(iperf_out)
return output
def runIperf(self, origin, origindev, dest, destdev, interval=1, duration=30, threads=1, protocol="tcp"):
prot_switch = None
if protocol == "tcp": prot_switch = ""
elif protocol == "udp": prot_switch = "-u"
else: raise xenrt.XRTError("unknown protocol %s" % (protocol,))
dest_endpoints = self.endpoints_of(dest)
origin_endpoints = self.endpoints_of(origin)
synexec_session = randrange(1000000000)
iperf_in_file = "/tmp/iperf.in.%s" % (synexec_session,)
iperf_out_file = "/tmp/iperf.out.%s" % (synexec_session,)
if dest.windows:
raise Exception("Windows endpoint not supported yet")
else:
# 1. start iperf servers in each vm in endpoint1s + endpoint1
for d in dest_endpoints:
# Start server
d.execcmd("nohup iperf %s -s 0<&- &>/dev/null &" % (prot_switch,)) # should be implemented in startIperf()
# 1.5. initialise synexec master in endpoint0
libsynexec.initialise_master_in_guest(origin)
# 2. start synexec slave in each vm in endpoint0s + endpoint0
for i in range(len(origin_endpoints)):
o = origin_endpoints[i]
d = dest_endpoints[i]
destIP = self.getIP(d, destdev)
libsynexec.start_slave(o, synexec_session)
o.execcmd("echo %s > %s" % (destIP, iperf_in_file))
# 3. create synexec master script in endpoint 0 to run iperf -c in each slave
master_script = """/bin/sh :CONF:
#!/bin/sh
DEST_IP=$(cat "%s")
iperf %s -c ${DEST_IP} -i %d -t %d -f m -P %d >%s 2>&1
""" % (iperf_in_file, prot_switch, interval, duration, threads, iperf_out_file)
self.log(None, "synexec_master_script=%s" % (master_script,))
if self.dopause.lower() == "on" or (xenrt.TEC().lookup("PAUSE_AT_MASTER_ON_PHASE", "None") in self.getPhase()):
self.pause('paused before running synexec_master') # pause the tc and wait for user assistance
# 4. start synexec master in endpoint0
# 5. wait for synexec master to finish (=all synexec slaves finished iperf -c)
master_out = libsynexec.start_master_in_guest(origin, master_script, synexec_session, len(origin_endpoints))
self.log(None, master_out)
# 6. kill iperf servers in each vm in endpoints1s + endpoint1
for d in dest_endpoints:
# Kill server
d.execcmd("killall iperf || true")
d.execcmd("killall -9 iperf || true")
for o in origin_endpoints:
libsynexec.kill_slave(o)
# 7. collect the iperf -c output in each endpoint0s + endpoint0
output = []
for o in origin_endpoints:
iperf_out = o.execcmd("cat %s" % (iperf_out_file,))
self.log(None, "collect results: endpoint %s: %s=%s" % (o, iperf_out_file, iperf_out))
output.append(iperf_out)
return output
