def all_events(interval:int=180*1000, warmup:int=15, vms=None):
from perf import perftool
events = perftool.get_events()
print("monitoring events:", events)
for vm in vms[1:]:
vm.stop()
vm = vms[0]
vm.start()
sleep(BOOT_TIME)
cpu = topology.no_ht[0]
vm.set_cpus([cpu])
result = {}
for bmark, cmd in basis.items():
wait_idleness(IDLENESS*4)
print("measuring", bmark)
vm.Popen(cmd)
sleep(warmup)
ipc = vm.stat(interval=interval, events=events)
result[bmark] = ipc
ret = vm.pipe.poll()
if ret is not None:
print("Test {bmark} on {vm} died with {ret}! Manual intervention needed\n\n" \
.format(bmark=bmark, vm=vm, ret=ret))
import pdb; pdb.set_trace()
vm.pipe.killall()
print(result)
return result
def isolated_perf(vms):
from subprocess import check_call
import shlex
benchmarks = "matrix wordpress blosc static sdag sdagp pgbench ffmpeg".split()
for bname, vm in zip(benchmarks, vms):
#if bname != 'wordpress':
# continue
wait_idleness(IDLENESS*6)
cmd = basis[bname]
pipe = vm.Popen(cmd, stdout=DEVNULL, stderr=DEVNULL)
sleep(10)
PERF = "/home/sources/perf_lite"
CMD = "{perf} kvm stat -e instructions,cycles -o {out} -x, -I {subinterval} -p {pid} sleep {sleep}"
out = "results/limit/isolated_perf_%s.csv" % bname
cmd = CMD.format(perf=PERF, pid=vm.pid,
out=out, subinterval=100, sleep=180)
check_call(shlex.split(cmd))
ret = pipe.poll()
if ret is not None:
print("Test {bmark} on {vm} died with {ret}! Manual intervention needed\n\n" \
.format(bmark=bname, vm=vm, ret=ret))
import pdb; pdb.set_trace()
pipe.killall()
def stop_tasks(vms):
for vm in vms:
if vm.pipe:
vm.pipe.killall()
vm.bmark = None
vm.pipe = None
wait_idleness(IDLENESS*6)
def __enter__(self):
map = {}
if not self.debug:
wait_idleness(IDLENESS*6)
for bname, vm in zip(self.benchmarks, self.vms):
#print("{} for {} {}".format(bname, vm.name, vm.pid))
cmd = basis[bname]
vm.pipe = vm.Popen(cmd, stdout=DEVNULL, stderr=DEVNULL)
vm.bname = bname
return map
def dead_opt_new(nr_vms:int=4, nr_samples:int=10, repeat:int=10, vms=None):
""" Like old one but reports more data. """
sys_speedup = []
reloc_speedup = []
all_speedup = []
for x in range(repeat):
prints("ITERATION {x} out of {repeat}")
wait_idleness(IDLENESS*4)
sys, vm, all = dead_opt1(nr_vms=nr_vms, nr_samples=nr_samples, vms=vms)
sys_speedup.append(sys)
reloc_speedup += vm
all_speedup += all
return Struct(sys_speedup=sys_speedup, reloc_speedup=reloc_speedup, all_speedup=all_speedup)
def interference(interval:int=180*1000, warmup:int=15, mode=None, vms=None):
assert mode in ['sibling', 'distant']
if mode == 'sibling':
cpu1 = topology.no_ht[0]
cpu2 = topology.ht_map[cpu1][0]
else:
cpu1, cpu2 = topology.no_ht[:2]
print("stopping all but 2 vms because we need only two")
for vm in vms[2:]:
vm.stop()
vm1, vm2 = vms[:2]
vm1.start()
vm2.start()
sleep(13)
vm1.set_cpus([cpu1])
vm2.set_cpus([cpu2])
benchmarks = list(sorted(basis))
result = defaultdict(lambda: [None, None])
for bmark1, bmark2 in product(benchmarks, repeat=2):
if (bmark2, bmark1) in result:
continue
key = (bmark1, bmark2)
print(key)
wait_idleness(IDLENESS*6)
p1 = vm1.Popen(basis[bmark1])
sleep(1) # reduce oscillation when two same applications are launched
p2 = vm2.Popen(basis[bmark2])
sleep(warmup)
def get_ipc(idx, vm):
ipc = vm.ipcstat(interval)
result[key][idx] = ipc
threadulator(get_ipc, [(0, vm1), (1, vm2)])
print(result)
for vm in [vm1, vm2]:
ret = vm.pipe.poll()
if ret is not None:
print("Test {bmark} on {vm} died with {ret}! Manual intervention needed\n\n" \
.format(bmark=vm.bname, vm=vm, ret=ret))
import pdb; pdb.set_trace()
p1.killall()
p2.killall()
help="output file")
args = parser.parse_args()
log.main.info("config:", args)
if args.debug:
cfg.idleness = 1000
cfg.sys_ipc_time = 0.1
else:
logfilter.rules = [
('profile.task.*', False)
]
if args.output:
out = open(args.output, 'at')
wait_idleness(cfg.idleness, t=3)
tasks = generate_load(num=len(topology.all))
try_all_permutations(tasks, out)
import sys; sys.exit()
#warm-up
sleep(cfg.warmup_time)
# initial performance
perf_before = get_sys_perf()
sys_optimize_dead_simple3(tasks)
# after tasks were optimized
perf_after = get_sys_perf()
improvement = (perf_after - perf_before) / perf_before * 100
