path: root/VNFs/DPPD-PROX/helper-scripts/testvRouter/characterize_vRouter_4_ports.py

#!/bin/env python

##
## Copyright (c) 2010-2017 Intel Corporation
##
## Licensed under the Apache License, Version 2.0 (the "License");
## you may not use this file except in compliance with the License.
## You may obtain a copy of the License at
##
##     http://www.apache.org/licenses/LICENSE-2.0
##
## Unless required by applicable law or agreed to in writing, software
## distributed under the License is distributed on an "AS IS" BASIS,
## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
## See the License for the specific language governing permissions and
## limitations under the License.
##

import socket
import sys
import os
from time import *
from datetime import  datetime
from optparse import OptionParser
import time
from remote_system import *
from math import log

# General parameters
accuracy = 0.1 	# in percent of line rate
max_dropped = 0.001		# in percent
all_pkt_size = [64,128,256,512,1024,1280,1518]
#all_pkt_size = [64]

# vRouter parameters, in case commands must be sent
vRouter_host = "192.168.1.96" 

# Stear parameters
step_time = 0.01		# in seconds
step_delta = 0.025		# in percent of line rate

# Use case dependent parameters
##### Use case 0: influence of number of routes and next hops #####
max_number_next_hops = 256			# Maximum number of next-hops per interface
max_number_routes = 8192			# Maximum number of routes per interface
max_number_addresses_local_network = 262144

##### Use case 1: packet loss and latency #####
low_steps_delta_for_loss = 0.01                 # Use increment of 0.01% from 0 to low_steps
medium_steps_delta_for_loss = 0.1               # Use increment of 0.1% from low_steps to medium_steps
normal_steps_delta_for_loss = 1.0               # Use increment of 1% from medium_steps till 100%
low_steps = 0.1 
medium_steps = 1.0 

# Prox parameters
tx_port0 = [19,27,55,63]
tx_port1 = [20,28,56,64]
tx_port2 = [21,29,57,65]
tx_port3 = [22,30,58,66]
tx_port4 = []
tx_port5 = []
tx_port6 = []
tx_port7 = []
tx_task = 0

all_rx_cores = [23,24,25,26]
rx_lat_cores = [23,24,25,26]
rx_task = 1

# Some variables, do not change

# Program arguments
parser = OptionParser()
parser.add_option("-d", "--duration", dest="test_duration", help="Duration of each steps", metavar="integer", default=10)
parser.add_option("-s", "--speed", dest="init_speed", help="Initial speed", metavar="integer", default=100)
parser.add_option("-u", "--use-case", dest="use_case", help="Use Case Number", metavar="integer", default=0)
parser.add_option("-r", "--run", dest="run", help="Run test", metavar="integer", default=0)
parser.add_option("-c", "--configure", dest="configure", help="Configure Test", metavar="integer", default=0)
(options, args) = parser.parse_args()

init_speed = int(options.init_speed)
test_duration = int(options.test_duration)
use_case = int(options.use_case)
configure = int(options.configure)
run = int(options.run)

nb_cores_per_interface = len(tx_port0)
max_speed = (100.0/nb_cores_per_interface)
init_speed = (init_speed * 1.0/nb_cores_per_interface)
accuracy = (accuracy * 1.0/nb_cores_per_interface)
normal_steps_delta_for_loss = (normal_steps_delta_for_loss /nb_cores_per_interface)
medium_steps_delta_for_loss = (medium_steps_delta_for_loss /nb_cores_per_interface)
low_steps_delta_for_loss = (low_steps_delta_for_loss /nb_cores_per_interface)
medium_steps = (medium_steps /nb_cores_per_interface)
low_steps = (low_steps /nb_cores_per_interface)

max_dropped = max_dropped / 100

def to_str(arr):
    ret = ""
    first = 1;
    for a in arr:
        if (first == 0):
            ret += ","

        ret += str(a)
        first = 0;
    return ret;

tx_cores = tx_port0 + tx_port1 + tx_port2 + tx_port3 + tx_port4 + tx_port5 + tx_port6 + tx_port7

def send_all_pkt_size(cores, pkt_size):
    for c in cores:
        sock.sendall("pkt_size " + str(c) + " 0 " + str(pkt_size) + "\n");

def send_all_value(cores, offset, value, len):
    for c in cores:
        sock.sendall("set value " + str(c) + " 0 " + str(offset) + " " + str(value) + " " + str(len)+ "\n");

def send_all_random(cores, offset, rand_str, len):
    for c in cores:
        sock.sendall("set random " + str(c) + " 0 " + str(offset) + " " + str(rand_str) + " " + str(len)+ "\n");
        #print("set random " + str(c) + " 0 " + str(offset) + " " + str(rand_str) + " " + str(len)+ "\n");

def send_all_speed(cores, speed_perc):
    for c in cores:
        sock.sendall("speed " + str(c) + " 0 " + str(speed_perc) + "\n");

def send_reset_random():
        sock.sendall("reset randoms all" + "\n");

def send_reset_value():
        sock.sendall("reset values all" + "\n");

def rx_stats(tx_cores, tx_task, rx_cores, rx_task):
	rx = tx = drop = tsc = tsc_hs = ierrors = 0
	for e in tx_cores:
		sock.sendall("core stats " + str(e) + " " + str(tx_task) +  "\n")
		recv = recv_once()
		rx += int(recv.split(",")[0])
		tx += int(recv.split(",")[1])
		drop += int(recv.split(",")[2])
		tsc = int(recv.split(",")[3])
		tsc_hz = int(recv.split(",")[4])
	for e in rx_cores:
		sock.sendall("core stats " + str(e) + " " + str(rx_task) +  "\n")
		recv = recv_once()
		rx += int(recv.split(",")[0])
		tx += int(recv.split(",")[1])
		drop += int(recv.split(",")[2])
		tsc = int(recv.split(",")[3])
		tsc_hz = int(recv.split(",")[4])
	# Also get the ierrors as generators might be the bottleneck...
	sock.sendall("tot ierrors tot\n")
	recv = recv_once()
	ierrors += int(recv.split(",")[0])
	rx+=ierrors
	return rx,tx,drop,tsc,tsc_hz

def lat_stats(cores,task):
	lat_min = [0 for e in range(127)]
	lat_max = [0 for e in range(127)]
	lat_avg = [0 for e in range(127)]
	for e in cores:
		sock.sendall("lat stats " + str(e) + " " + str(task) + " " +  "\n")
		recv = recv_once()
		lat_min[e] = int(recv.split(",")[0])
		lat_max[e] = int(recv.split(",")[1])
		lat_avg[e] = int(recv.split(",")[2])
	return lat_min, lat_max, lat_avg

def recv_once():
    ret_str = "";
    done = 0;
    while done == 0:
        dat = sock.recv(256);
        i = 0;
        while(i < len(dat)):
            if (dat[i] == '\n'):
                done = 1
            else:
                ret_str += dat[i];
            i = i + 1;
    return ret_str

def wait_vRouter_restarted(host):
	while (1):
		ret = os.system("ping " + host + " -c 1 > /dev/null")
		if ret == 0:
			print "still up..."
		else:
			break;
		sleep(1)
	
	while (1):
		ret = os.system("ping " + host + " -c 1 > /dev/null")
		if (ret == 0):
			print "UP"
			break;
		else:
			print "still down..."
			sleep(1)

def reload_vRouter_config(config):
	print "connecting to vRouter...and copying " + str(config)
	sut = remote_system("root", vRouter_host)
	cmd = "cp /config/prox/" + str(config) + " /config/config.boot"
	sut.run(cmd)
	print "Rebooting system at " + str(datetime.now().time())
	sut.run_forked("reboot")
	sleep(5)
	wait_vRouter_restarted(vRouter_host)
	print "Waiting for last startup scripts to start..."
	last_script = "l2tp"
	while(1):
		dmesg = str(sut.run("dmesg"))
		if last_script in dmesg:
			print "found l2tp - UP"
			break;
		sleep(1)
	print "vRouter started - waiting 5 last seconds before starting test"
	sleep(5)
	print datetime.now().time()

def set_pkt_sizes(tx_cores, p):
	send_all_pkt_size(tx_cores, p-4)
	# For all cores, need to adapt IP Length (byte 16) and UDP Length (byte 38) to pkt size
	send_all_value(tx_cores, 16, p - 18, 2)		# 14 for MAC (12) EthType (2) 
	send_all_value(tx_cores, 38, p - 38, 2)		# 34 for MAC (12) EthType (2) IP (20)

def run_measure_throughput(speed):
	done = 0
	# Intialize tests by stopping cores and resetting stats
	step=0
	steps_done = 0
	sock.sendall("start " + to_str(all_rx_cores) + "\n")
	sleep(2)
	sock.sendall("stop " + to_str(all_rx_cores) + "\n")
	sock.sendall("reset stats\n")
	print "Speed    = " + str(speed * nb_cores_per_interface) 
	sleep(1);
	
	send_all_speed(tx_cores, step);

	# Now starting the steps. First go to the common speed, then increase steps for the faster one.
	sock.sendall("start " + to_str(tx_cores) + "," + to_str(rx_lat_cores) + "\n")
	while (steps_done == 0):
		sleep(step_time)
		if (step + step_delta <= speed):
			step+=step_delta
		else:
			steps_done = 1;
		send_all_speed(tx_cores, step)
	
	# Steps are now OK.  Set speed
	send_all_speed(tx_cores, speed);
	sleep(2);

	# Getting statistics to calculate PPS at right speed....
	rx_pps_beg,tx_pps_beg,drop_pps_beg,tsc_pps_beg,tsc_hz = rx_stats(tx_cores, tx_task, all_rx_cores, rx_task);
	sleep(test_duration);

	# Collect statistics before test stops...and stop the test. Important to get stats before stopping as stops take some time...
	rx_pps_end,tx_pps_end,drop_pps_end,tsc_pps_end,tsc_hz = rx_stats(tx_cores, tx_task, all_rx_cores, rx_task);
	lat_min,lat_max,lat_avg = lat_stats(rx_lat_cores, rx_task)
	sock.sendall("stop " + "," + to_str(tx_cores) + "\n")
	sock.sendall("start " + to_str(all_rx_cores) + "\n")
	sleep(3);
	sock.sendall("stop " + to_str(all_rx_cores) + "\n")
	
	rx_end, tx_end,drop_end,tsc_end,tsc_hz = rx_stats(tx_cores, tx_task, all_rx_cores, rx_task);
	rx = rx_pps_end - rx_pps_beg
	tsc = tsc_pps_end - tsc_pps_beg
	mpps = rx / (tsc/float(tsc_hz)) / 1000000
	tx = tx_pps_end - tx_pps_beg
	tx_mpps = tx / (tsc/float(tsc_hz)) / 1000000
	
	#print "Runtime = " +  str((tsc)/float(tsc_hz));
	if (tx_end == 0):
		dropped_tot = tx_end - rx_end
		dropped_pct = 0
	else:
		dropped_tot = tx_end - rx_end
		dropped_pct = ((dropped_tot) * 1.0) / tx_end

	if (dropped_tot > 0):
		if (dropped_pct >= max_dropped):
			print "** FAILED **: lost " + str(100*dropped_pct) + "% packets RX = " + str(rx_end) + " TX = " + str(tx_end) + " DROPPED = " + str(tx_end - rx_end)
		else:
			print "OK but lost " + str(100*dropped_pct) + "% packets RX = " + str(rx_end) + " TX = " + str(tx_end) + " DROPPED = " + str(tx_end - rx_end)
	else:
		if (dropped_tot < 0):
			print "Something wrong happened - received more packets than transmitted"
		else:
			print "**   OK   **: RX = " + str(rx_end) + " TX = " + str(tx_end) + " DROPPED = " + str(tx_end - rx_end) 
	print "MPPS = " + str(mpps)
	print "===================================================="
	return dropped_pct, mpps, tx_mpps, dropped_tot,lat_min,lat_max,lat_avg

def write_results(f, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, lat_min, lat_max, lat_avg):
	f.write(str(pkt_size) + "; " + str(tx_mpps) + "; " + str(mpps) + "; " + str(100 * dropped_pct) + "; " + str(dropped_tot) + "; " + str(speed * nb_cores_per_interface) + "; " + str(number_next_hops) + "; " + str(number_routes) + "; " + str(traffic) + "; ")
	for e in rx_lat_cores:
		f.write(str(lat_min[e]) + "; " + str(lat_max[e]) + "; " + str(lat_avg[e]) + "; ")
	f.write("\n");
	f.flush()

def run_loss_graph(number_next_hops, number_routes, pkt_size, traffic):
	speed = init_speed * 1.0
	done = 0;
	while done == 0:
		dropped_pct, mpps, tx_mpps, dropped_tot,lat_min,lat_max,lat_avg = run_measure_throughput(speed)
		write_results(f, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, lat_min, lat_max, lat_avg);
		if (speed <= low_steps_delta_for_loss):
			done = 1
			return
		if (speed >= (medium_steps+normal_steps_delta_for_loss)):
			speed -= normal_steps_delta_for_loss
		else:
			if (speed >= (low_steps+medium_steps_delta_for_loss)):
				speed -= medium_steps_delta_for_loss
			else:
				speed -= low_steps_delta_for_loss

def run_dicho_search(number_next_hops, number_routes, pkt_size, traffic):
	previous_success_speed = 0.0
	previous_error_speed = max_speed
	speed = init_speed * 1.0
	done = 0;
	good_tx_mpps = 0
	good_mpps = 0
	good_dropped_pct = 0
	good_dropped_tot = 0
	good_speed = 0
	good_lat_min = [0 for e in range(127)]
	good_lat_max = [0 for e in range(127)]
	good_lat_avg = [0 for e in range(127)]

	while done == 0:
		dropped_pct, mpps, tx_mpps, dropped_tot,lat_min,lat_max,lat_avg = run_measure_throughput(speed)
		if ((dropped_tot >= 0) and (dropped_pct <= max_dropped)):
			good_tx_mpps = tx_mpps
			good_mpps = mpps
			good_dropped_pct = dropped_pct
			good_dropped_tot = dropped_tot
			good_speed = speed
			good_lat_min = lat_min
			good_lat_max = lat_max
			good_lat_avg = lat_avg
			write_results(f, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, lat_min, lat_max, lat_avg);
			write_results(f_all, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, lat_min, lat_max, lat_avg);
		else:
			write_results(f_all, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, lat_min, lat_max, lat_avg);

		if ((speed == max_speed) and (dropped_pct <= max_dropped)):
			write_results(f_minimal, pkt_size, tx_mpps, mpps, dropped_pct, dropped_tot, speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, lat_min, lat_max, lat_avg);
			done = 1
		if (dropped_pct <= max_dropped):
			previous_success_speed = speed
			if (speed > max_speed - accuracy):
				speed = max_speed
			else:
				if (previous_error_speed - speed < accuracy):
					write_results(f_minimal, pkt_size, good_tx_mpps, good_mpps, good_dropped_pct, good_dropped_tot, good_speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, good_lat_min, good_lat_max, good_lat_avg);
					done = 1
				else:
					speed = speed + (previous_error_speed - speed)/2;
		else:
			previous_error_speed = speed
			if (speed - previous_success_speed < accuracy):
				write_results(f_minimal, pkt_size, good_tx_mpps, good_mpps, good_dropped_pct, good_dropped_tot, good_speed, nb_cores_per_interface, number_next_hops, number_routes, traffic, good_lat_min, good_lat_max, good_lat_avg);
				done = 1	
			else:
				speed  = speed - (speed - previous_success_speed) / 2;

	
def set_destination_ip(use_case, nb_destinations, traffic):
	# minimmum 8 routes i.e. 1 per interface 
	# Destination addressese: "00XXXYY1" "Z00ZZ0ZZ" "AA0AA0AA" "BBBBBB10"
	# Where X = interface id. Starting with 00 to be in class A and skipping 0.x.y.z and 127.x.y.z
	# Y, Z and A = additional routes
	# B = IP in routes. 10 to avoid x.y.z.0 and x.y.z.255
	# Gaps in A and B to void "too good" distributions e.g. using LPM and 
	# First changing Y

	mask = ""
	for i in range (2):
       		mask = str(mask)+"0"
	end_mask = ""
	if (use_case != 2):
		end_mask = "XXXXXX10"		# Last 8 bits

		if (nb_destinations == 1):
			end_mask = "0010000000000000000" + str(end_mask)
		if (nb_destinations == 2):
			end_mask = "X010000000000000000" + str(end_mask)
		if (nb_destinations == 4):
			end_mask = "XX10000000000000000" + str(end_mask)
		if (nb_destinations == 8):
			end_mask = "XX1X000000000000000" + str(end_mask)
		elif (nb_destinations == 16):
			end_mask = "XX1X00X000000000000" + str(end_mask)
		elif (nb_destinations == 32):
			end_mask = "XX1X00XX00000000000" + str(end_mask)
		elif (nb_destinations == 64):
			end_mask = "XX1X00XX0X000000000" + str(end_mask)
		elif (nb_destinations == 128):
			end_mask = "XX1X00XX0XX00000000" + str(end_mask)
		elif (nb_destinations == 256):
			end_mask = "XX1X00XX0XXX0000000" + str(end_mask)
		elif (nb_destinations == 512):
			end_mask = "XX1X00XX0XXXX000000" + str(end_mask)
		elif (nb_destinations == 1024):
			end_mask = "XX1X00XX0XXXX0X0000" + str(end_mask)
		elif (nb_destinations == 2048):
			end_mask = "XX1X00XX0XXXX0XX000" + str(end_mask)
		elif (nb_destinations == 4096):
			end_mask = "XX1X00XX0XXXX0XX0X0" + str(end_mask)
		elif (nb_destinations == 8192):
			end_mask = "XX1X00XX0XXXX0XX0XX" + str(end_mask)
	else:
		if (nb_destinations <= 64 * 1):
			end_mask = "0010000000000000000"
			n_dest = int(log(nb_destinations, 2))
			for i in range (n_dest):
				end_mask = str(end_mask) + "X"
			for i in range (6 - n_dest):
				end_mask = str(end_mask) + "0"
			end_mask = str(end_mask) + "10"
		else:
			end_mask = "XXXXXX10"		# Last 8 bits

		if (nb_destinations == 64 * 2):
			end_mask = "001X000000000000000" + str(end_mask)
		elif (nb_destinations == 64 * 4):
			end_mask = "001X00X000000000000" + str(end_mask)
		elif (nb_destinations == 64 * 8):
			end_mask = "001X00XX00000000000" + str(end_mask)
		elif (nb_destinations == 64 * 16):
			end_mask = "001X00XX0X000000000" + str(end_mask)
		elif (nb_destinations == 64 * 32):
			end_mask = "001X00XX0XX00000000" + str(end_mask)
		elif (nb_destinations == 64 * 64):
			end_mask = "001X00XX0XXX0000000" + str(end_mask)
		elif (nb_destinations == 64 * 128):
			end_mask = "001X00XX0XXXX000000" + str(end_mask)
		elif (nb_destinations == 64 * 256):
			end_mask = "001X00XX0XXXX0X0000" + str(end_mask)
		elif (nb_destinations == 64 * 512):
			end_mask = "001X00XX0XXXX0XX000" + str(end_mask)
		elif (nb_destinations == 64 * 1024):
			end_mask = "001X00XX0XXXX0XX0X0" + str(end_mask)
		elif (nb_destinations == 64 * 2048):
			end_mask = "001X00XX0XXXX0XX0XX" + str(end_mask)
		elif (nb_destinations == 64 * 4096):
			end_mask = "001XX0XX0XXXX0XX0XX" + str(end_mask)
		elif (nb_destinations == 64 * 8192):
			end_mask = "001XXXXX0XXXX0XX0XX" + str(end_mask)
		elif (nb_destinations == 64 * 16384):
			end_mask = "001XXXXXXXXXX0XX0XX" + str(end_mask)
		elif (nb_destinations == 64 * 32768):
			end_mask = "001XXXXXXXXXXXXX0XX" + str(end_mask)
		elif (nb_destinations == 64 * 65536):
			end_mask = "001XXXXXXXXXXXXXXXX" + str(end_mask)
	
	if (traffic == 0):	# One-to-one. From odd interface to even interface and vice versa, no QPI cross
		mask1 = str(mask) + "001" + str(end_mask)
		mask2 = str(mask) + "000" + str(end_mask)
		mask3 = str(mask) + "011" + str(end_mask)
		mask4 = str(mask) + "010" + str(end_mask)
		mask5 = str(mask) + "101" + str(end_mask)
		mask6 = str(mask) + "100" + str(end_mask)
		mask7 = str(mask) + "111" + str(end_mask)
		mask8 = str(mask) + "110" + str(end_mask)

	elif (traffic == 1):	# Full mesh within QPI (i.e. 1 to 4)
		mask1 = str(mask) + "0XX" + str(end_mask)
		mask2 = str(mask) + "0XX" + str(end_mask)
		mask3 = str(mask) + "0XX" + str(end_mask)
		mask4 = str(mask) + "0XX" + str(end_mask)
		mask5 = str(mask) + "1XX" + str(end_mask)
		mask6 = str(mask) + "1XX" + str(end_mask)
		mask7 = str(mask) + "1XX" + str(end_mask)
		mask8 = str(mask) + "1XX" + str(end_mask)
	
	elif (traffic == 2):	# One to one, crossing QPI (100% QPI)
		mask1 = str(mask) + "100" + str(end_mask)
		mask2 = str(mask) + "101" + str(end_mask)
		mask3 = str(mask) + "110" + str(end_mask)
		mask4 = str(mask) + "111" + str(end_mask)
		mask5 = str(mask) + "000" + str(end_mask)
		mask6 = str(mask) + "001" + str(end_mask)
		mask7 = str(mask) + "010" + str(end_mask)
		mask8 = str(mask) + "011" + str(end_mask)

	elif (traffic == 3):	# 1 to 4 crossing QPI (100% QPI)
		mask1 = str(mask) + "1XX" + str(end_mask)
		mask2 = str(mask) + "1XX" + str(end_mask)
		mask3 = str(mask) + "1XX" + str(end_mask)
		mask4 = str(mask) + "1XX" + str(end_mask)
		mask5 = str(mask) + "0XX" + str(end_mask)
		mask6 = str(mask) + "0XX" + str(end_mask)
		mask7 = str(mask) + "0XX" + str(end_mask)
		mask8 = str(mask) + "0XX" + str(end_mask)

	elif (traffic == 4):	# 1 to 4 (50% QPI)
		mask1 = str(mask) + "XX1" + str(end_mask)
		mask2 = str(mask) + "XX0" + str(end_mask)
		mask3 = str(mask) + "XX1" + str(end_mask)
		mask4 = str(mask) + "XX0" + str(end_mask)
		mask5 = str(mask) + "XX1" + str(end_mask)
		mask6 = str(mask) + "XX0" + str(end_mask)
		mask7 = str(mask) + "XX1" + str(end_mask)
		mask8 = str(mask) + "XX0" + str(end_mask)

	elif (traffic == 5):	# Full mesh (50% QPI)
		mask1 = str(mask) + "XXX" + str(end_mask)
		mask2 = str(mask) + "XXX" + str(end_mask)
		mask3 = str(mask) + "XXX" + str(end_mask)
		mask4 = str(mask) + "XXX" + str(end_mask)
		mask5 = str(mask) + "XXX" + str(end_mask)
		mask6 = str(mask) + "XXX" + str(end_mask)
		mask7 = str(mask) + "XXX" + str(end_mask)
		mask8 = str(mask) + "XXX" + str(end_mask)

	for c in tx_port0:
		send_all_random([c], 30, mask1, 4)
	for c in tx_port1:
		send_all_random([c], 30, mask2, 4)
	for c in tx_port2:
		send_all_random([c], 30, mask3, 4)
	for c in tx_port3:
		send_all_random([c], 30, mask4, 4)
	for c in tx_port4:
		send_all_random([c], 30, mask5, 4)
	for c in tx_port5:
		send_all_random([c], 30, mask6, 4)
	for c in tx_port6:
		send_all_random([c], 30, mask7, 4)
	for c in tx_port7:
		send_all_random([c], 30, mask8, 4)
	for c in tx_cores:
		send_all_random([c], 34, "0XXXXXXXXXXXXX10", 2)
		send_all_random([c], 36, "0XXXXXXXXXXXXX10", 2)

#========================================================================
class TestDefinition():
    "Stores test parameters"
    def __init__(self, use_case, next_hops, number_routes, pkt_size, traffic, reload):
        self.use_case = use_case
        self.next_hops = next_hops
        self.number_routes = number_routes
        self.pkt_size = pkt_size
        self.traffic = traffic
        self.reload = reload

#========================================================================
# Use case 0 increases input load and measure output load => show dropped packets at low loads, show overload behavior
# Use case 1 and use case 2 run dichotomic searches, searching for 0 packet loss (or whaever loss is configured)
# Use case 1 shows the effect of number of routes and next-hops
# Use case 2 shows the effect of the number of destination, using a fixed (low) number of routes and next-hops
#========================================================================
def run_use_case(use_case, number_next_hops, number_routes, pkt_size, traffic, reload):
	if (reload):
		if (use_case == 2):
			config = "config.1_1" + "_" + str(use_case) + ".boot"
		else:
			config = "config." + str(number_routes) + "_" + str(number_next_hops) + ".boot"
		reload_vRouter_config(config)
	send_reset_random()
	send_reset_value()
	set_destination_ip(use_case, number_routes, traffic)
	set_pkt_sizes(tx_cores, pkt_size)
	print "Running test with pkt size= " + str(pkt_size) + " Next hops = " + str(number_next_hops) + "; number of routes = " + str(number_routes) + "; Traffic = " + str(traffic) + " \n"
	if (use_case == 0):
		run_loss_graph(number_next_hops, number_routes, pkt_size, traffic)
	else:
		run_dicho_search(number_next_hops, number_routes, pkt_size, traffic)
	sleep(3)

#========================================================================
def run_all_use_cases():
	use_case_nb = 1
	# Connect to dppd 
	file_path = '/tmp/prox.sock'
	sock.connect(file_path)

	f.write("pkt_size; tx_mpps; rx_mpps; dropped_pct; dropped_tot; percent_line_rate; latency per core\n")
	f_all.write("pkt_size; tx_mpps; rx_mpps; dropped_pct; dropped_tot; percent_line_rate; latency per core\n")
	f_minimal.write("pkt_size; tx_mpps; rx_mpps; dropped_pct; dropped_tot; percent_line_rate; latency per core\n")
	f.flush();
	f_all.flush();
	f_minimal.flush();

	# Starting tests
	print "Stopping all cores and resetting all values and randoms before starting\n"
	sock.sendall("stop all")
	sock.sendall("reset stats\n")
	sleep(3);
	for line in file_tests:
		info = line.split(';')
		if (info[0][0] == '#'):
			continue
		if (info[0][0] == ''):
			break
		use_case = int(info[0])
		next_hops = int(info[1])
		number_routes = int(info[2])
		pkt_size = int(info[3])
		traffic = int(info[4])
		reload = int(info[5])
		print str(use_case_nb) + " : Running use case " + str(use_case) + " next_hops = " + str(next_hops) + " routes = " + str(number_routes) + " pkt_size = " + str(pkt_size) + " traffic = " + str(traffic) + " reload = " + str(reload)
		run_use_case(use_case, next_hops, number_routes, pkt_size, traffic, reload)
		use_case_nb = use_case_nb + 1

#========================================================================
def configure_use_case(use_case):
	Tests = []
	if (use_case == 0):
		for pkt_size in all_pkt_size:
			Tests.append(TestDefinition("0", "1", "1", pkt_size, "0", "1"))
		for pkt_size in all_pkt_size:
			Tests.append(TestDefinition("0", "1", "1", pkt_size, "1", "1"))
	if (use_case == 1):
		number_next_hops = 1
		reload = 0

		number_routes = number_next_hops	# At least same number of routes that number of next hops
		while number_routes <= max_number_routes:
			reload = 1
			for traffic in range(6):
				for pkt_size in all_pkt_size:
					Tests.append(TestDefinition(use_case, number_next_hops, number_routes, pkt_size, traffic, reload))
					reload = 0
			if (number_routes < max_number_routes / 2):
				number_routes = number_routes * 4
			else:
				number_routes = number_routes * 2

		number_routes = max_number_next_hops
		while number_next_hops <= max_number_next_hops:
			reload = 1
			for traffic in range(6):
				for pkt_size in all_pkt_size:
					Tests.append(TestDefinition(use_case, number_next_hops, number_routes, pkt_size, traffic, reload))
					reload = 0
			number_next_hops = number_next_hops * 2
	if (use_case == 2):
		number_next_hops = 1
		reload = 1
		for traffic in range(6):
			nb_destinations = 1
			while nb_destinations <= max_number_addresses_local_network:
				for pkt_size in all_pkt_size:
					Tests.append(TestDefinition(use_case, number_next_hops, nb_destinations, pkt_size, traffic, reload))
					reload = 0
				nb_destinations = nb_destinations * 2
			reload = 1

	file_tests = open('test_description.txt', 'w')
	file_tests.write("# Use case; next_hops; routes; pkt_size; traffic; reload;\n")
	for test in Tests:
		file_tests.write(str(test.use_case) + "; " + str(test.next_hops) + "; " +  str(test.number_routes) + "; " + str(test.pkt_size) + "; " + str(test.traffic) + "; " + str(test.reload) + ";\n")
	file_tests.close()

#========================================================================
if ((configure == 0) and (run == 0)):
	print "Nothing to do - please use -r 1 or -c 1"
if (configure == 1):
	configure_use_case(use_case)
if (run == 1):
	print "****************************************************************************************************************"
	print "** Running vRouter Characterization with " + str(test_duration) + " seconds steps and starting at " + str(init_speed)   + " percent of line rate **"
	print "****************************************************************************************************************"
	sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
	f_all = open('all_results.txt', 'w')
	f = open('detailed_results.txt', 'w')
	f_minimal = open('minimal_results.txt', 'w')
	file_tests = open('test_description.txt', 'r')
	run_all_use_cases()
	f.close();
	sock.close();