def get_processor(benchmark):
if benchmark.contains('same-container') or benchmark.contains('same-core'):
return util.processor(0)
elif benchmark.contains('different-logical-core'):
return util.virtual_processor(0)
elif benchmark.contains('different-core'):
return util.processor(1)
else:
raise Exception('Benchmark.get_processor: Not implemented')
def check_processor(args, name):
if args.container == "docker":
print("here")
command = "sudo docker inspect -f '{{{{.HostConfig.CpusetCpus}}}}' {0:s}".format(name)
print(command)
output = util.shell_output(command).strip()
print(output)
elif args.container == "linux":
output = util.shell_output("lxc-cgroup -n {0:s} cpuset.cpus".format(name)).strip()
else:
return
print(output)
if output != str(util.processor(0)):
raise Exception("Error. Container is not bound to processor {0:d}".format(util.processor(0)))
def setup_linux(args):
install_linux_dependencies()
if args.process == "nginx":
name = NGINX_CONTAINER_NAME
container_ip = get_linux_container_ip(name)
container_port = NGINX_CONTAINER_PORT
machine_port = NGINX_MACHINE_PORT
if container_ip is None:
setup_linux_nginx_container()
elif args.process == "memcached":
name = MEMCACHED_CONTAINER_NAME
container_ip = get_linux_container_ip(name)
container_port = MEMCACHED_CONTAINER_PORT
machine_port = MEMCACHED_MACHINE_PORT
if container_ip is None:
setup_linux_memcached_container()
util.shell_call("sudo lxc-cgroup -n {0:s} memory.limit_in_bytes 1G".format(name))
else:
raise "setup_linux: Not implemented"
container_ip = get_linux_container_ip(name)
if args.cores > 1:
raise Exception("Error need to implement logic for multiple cores")
util.shell_call("sudo lxc-cgroup -n {0:s} cpuset.cpus {1:d}".format(name, util.processor(0)))
check_processor(args, name)
machine_ip = get_ip_address('eno1')
bridge_ip = get_ip_address('lxcbr0')
print("machine", machine_ip, machine_port, "container", container_ip, container_port, "bridge", bridge_ip)
setup_port_forwarding(machine_ip, machine_port, container_ip, container_port, bridge_ip)
print("To benchmark run 'python docker_setup.py -c linux -p {0:s} -b {1:s}:{2:d}'".format(args.process, machine_ip, machine_port))
def create_docker_nginx_container(args, docker_filter, is_xcontainer=False):
configuration_file_path = '/dev/nginx.conf'
setup_nginx_configuration(configuration_file_path)
print(NGINX_CONTAINER_NAME, docker_filter)
address = docker_ip(NGINX_CONTAINER_NAME, docker_filter)
if args.cores > 1:
raise "multi-core not implemented"
cpu = "--cpuset-cpus={0:d}".format(util.processor(0))
if is_xcontainer:
cpu = ""
if address is None:
command = 'docker run --name {0:s} -P {1:s} -v {2:s}:/etc/nginx/nginx.conf:ro -d nginx'
print(command)
util.shell_call(command.format(NGINX_CONTAINER_NAME, cpu, configuration_file_path))
container_sleep(5)
address = docker_ip(NGINX_CONTAINER_NAME, docker_filter)
ports = nginx_docker_port()
if is_xcontainer:
machine_ip = get_ip_address('em1')
else:
machine_ip = get_ip_address('eno1')
bridge_ip = get_ip_address('docker0')
setup_port_forwarding(machine_ip, int(ports[1]), address, int(ports[0]), bridge_ip)
print("To benchmark run 'python docker_setup.py -c docker -p nginx -b {0:s}:{1:s}'".format(machine_ip, ports[1]))
return ports
def setup_xcontainer(args):
if args.process == "nginx":
name = NGINX_CONTAINER_NAME
container_port = NGINX_CONTAINER_PORT
machine_port = NGINX_MACHINE_PORT
create_docker_nginx_container(args, XCONTAINER_INSPECT_FILTER, True)
elif args.process == "memcached":
name = MEMCACHED_CONTAINER_NAME
container_port = MEMCACHED_CONTAINER_PORT
machine_port = MEMCACHED_MACHINE_PORT
setup_docker_memcached_container(args, XCONTAINER_INSPECT_FILTER, True)
else:
raise Exception("setup_xcontainer: not implemented")
docker_id = util.shell_output('docker inspect --format="{{{{.Id}}}}" {0:s}'.format(name)).strip()
bridge_ip = get_ip_address('xenbr0')
xcontainer_ip = generate_xcontainer_ip(bridge_ip)
util.shell_call('docker stop {0:s}'.format(name))
machine_ip = get_ip_address('em1')
util.shell_call('tmux new -s xcontainer -d')
tmux_command('xcontainer', 'cd /root/experiments/native/compute06/docker')
tmux_command('xcontainer', 'python run.py --id {0:s} --ip {1:s} --hvm --name {2:s} --cpu={3:d}'.format(docker_id, xcontainer_ip, name, args.cores))
container_sleep(5)
setup_port_forwarding(machine_ip, machine_port, xcontainer_ip, container_port, bridge_ip)
print('Setup {0:s} X-Container on {1:s}:{2:d}'.format(args.process, machine_ip, machine_port))
util.shell_call('xl vcpu-pin memcached_container 0 {0:d}'.format(util.processor(0)))
util.shell_call('python /root/x-container/irq-balance.py')
util.shell_call('python /root/x-container/cpu-balance.py')
def create_readme(args, folder):
last_commit = util.shell_output('git log --oneline -n 1')
num_connections = get_num_connections(args)
rates = get_rates(args)
f = open('{0:s}/README'.format(folder), 'w+')
f.write('LAST COMMIT: {0:s}\n'.format(last_commit))
f.write('CONTAINER: {0:s}\n'.format(args.container))
f.write('PROCESS: {0:s}\n'.format(args.process))
f.write('BENCHMARK ADDRESS: {0:s}\n'.format(args.benchmark_address))
f.write('NUM CLIENTS: {0:d}\n'.format(args.cores))
f.write('DURATION: {0:d}\n'.format(args.duration))
f.write('CONNECTIONS: {0:d}\n'.format(args.connections))
f.write('NUM CONNECTIONS PER CLIENT: {0:d}\n'.format(num_connections))
f.write('RATES: {0:s}\n'.format(str(rates)))
f.write('THREADS: {0:d}\n'.format(args.threads))
f.write('DATE: {0:s}\n'.format(args.date))
f.write("BOUND TO PROCESSOR: {0:d}\n".format(util.processor(0)))
f.write('BENCHMARK TEST: {0:s}\n'.format(args.test))
f.write('NUM INTERFERENCE: {0:d}\n'.format(NUM_INTERFERENCE))
if args.process == 'memcached':
f.write('MEMCACHED SIZE(-m): {0:d}M\n'.format(MEMCACHED_SIZE))
f.write('MEMCACHED THREADS(-t): {0:d}\n'.format(MEMCACHED_THREADS))
f.close()
def setup_docker_memcached_container(args, docker_filter, is_xcontainer=False):
address = docker_ip(MEMCACHED_CONTAINER_NAME, docker_filter)
configuration_file_path = '/dev/memcached.conf'
setup_memcached_configuration(configuration_file_path)
address = docker_ip(MEMCACHED_CONTAINER_NAME, docker_filter)
if args.cores > 1 and not is_xcontainer:
raise "multi-core not implemented"
cpu = "--cpuset-cpus={0:d}".format(util.processor(0))
if is_xcontainer:
cpu = ""
if address is None:
# TODO: Way to pass in memcached parameters like memory size
util.shell_call('docker run --name {0:s} -P {1:s} -p 0.0.0.0:{2:d}:{3:d} -d memcached memcached -m {4:d} -u root -t {5:d}'
.format(MEMCACHED_CONTAINER_NAME, cpu, MEMCACHED_MACHINE_PORT, MEMCACHED_CONTAINER_PORT, MEMCACHED_SIZE, MEMCACHED_THREADS)
)
address = docker_ip(MEMCACHED_CONTAINER_NAME, docker_filter)
else:
util.shell_call('docker start --name {0:s}'.format(MEMCACHED_CONTAINER_NAME))
check_processor(args, MEMCACHED_CONTAINER_NAME)
ports = memcached_docker_port()
print(ports)
if is_xcontainer:
container = "xcontainer"
machine_ip = get_ip_address('em1')
else:
container = "docker"
machine_ip = get_ip_address('eno1')
bridge_ip = get_ip_address('docker0')
setup_port_forwarding(machine_ip, MEMCACHED_MACHINE_PORT, address, int(ports[0]), bridge_ip)
if not is_xcontainer:
print("To benchmark run 'python docker_setup.py -c {0:s} -p memcached -b {1:s}:{2:d}'".format(container, machine_ip, MEMCACHED_MACHINE_PORT))
return ports