def test():
pktgen = Pktgen(config.active_config)
pktgen.low_level_start(pkt_count=20, pkt_size=1500, gap_ns=500000000, flow_count=20) # half a second gap
util.verbose_sleep(10, 'Waiting for pktgen to finish')
result = pktgen.stop_and_get_result()
print result.__dict__
def test():
""" Sanity check. """
proxy_client = StateProxyClient(FLEXI_CONTROLLER_HOST)
proxy_client.reset()
send_trigger_packet()
# print '*' * 80
# print 'ingress -> pkt-in'
# print '*' * 80
#
# ingress = GenerateIngress(300, proxy_client)
# pkt_in = ReceivePktIn(proxy_client)
#
# pkt_in.start()
# ingress.start()
# util.verbose_sleep(20, 'Ingress -> pkt_in...')
# ingress.stop()
# pkt_in.stop()
#
# print 'sent pps:', ingress.get_sent_pps()
# print 'recvd pps:', pkt_in.get_received_pps()
#
# print '*' * 80
# print 'flow-mod -> rules'
# print '*' * 80
#
# flow_mod = GenerateFlowMod(200, proxy_client)
# check_rule = CheckRuleInstallationRate(proxy_client, flow_stat_interval=10, steady_state_start=30, steady_state_end=60)
#
# check_rule.start()
# flow_mod.start()
# util.verbose_sleep(60, 'flow-mod -> rules')
# flow_mod.stop()
# check_rule.stop()
#
# print 'sent pps:', flow_mod.get_sent_pps()
# print 'recvd pps:', check_rule.get_received_pps()
print '*' * 80
print 'pkt-out -> egress'
print '*' * 80
pkt_out = GeneratePktOut(200, proxy_client, packet_size=1500)
egress = ReceiveEgress(proxy_client)
egress.start()
pkt_out.start()
util.verbose_sleep(5, 'pkt-out -> egress')
pkt_out.stop()
egress.stop()
print 'sent pps:', pkt_out.get_sent_pps()
print 'recvd pps:', egress.get_received_pps()
def __init__(self):
# Publish the value of x onto the redis server.
self.init_redis_server()
# Remove previous temp data files.
for client_data_file in os.listdir('.'):
if client_data_file.endswith('.tmp'):
os.remove(client_data_file)
# Construct the new experiment state, thereby starting the experiment.
experiment_state = ExperimentState()
experiment_state.data_length = DATA_LENGTH
experiment_state.gap_ms = EXPECTED_GAP_MS * REDIS_CLIENT_PROCESS_COUNT * REDIS_CLIENT_HOST_COUNT
experiment_state.redis_server = REDIS_SERVER_IN_BAND
experiment_state.uid = str(random.random())[2:6]
with open(EXPERIMENT_STATE_FILE, 'w') as f:
f.write(pickle.dumps(experiment_state))
# Wait and stop.
print 'Experiment State:', experiment_state.__dict__
util.verbose_sleep(130, 'Collecting data...')
os.remove(EXPERIMENT_STATE_FILE)
# Waiting for all data files to be ready. The number of files to expect
# is equal to the number of *.dummy files with the current experiment
# UID.
data_file_count = 0
for filename in os.listdir('.'):
if filename.startswith('dummy-' + experiment_state.uid):
data_file_count += 1
client_data_file_list = []
while len(client_data_file_list) < data_file_count:
print 'Waiting for all data files to be ready.',
print 'Current:', len(client_data_file_list),
print 'Expected total:', data_file_count
time.sleep(5)
client_data_file_list = []
for filename in os.listdir('.'):
if filename.startswith('data-' + experiment_state.uid):
client_data_file_list += [filename]
# Join data.
start_end_times = []
for client_data_file in client_data_file_list:
print 'Reading', client_data_file
with open(client_data_file) as f:
client_data_list = pickle.loads(f.read())
start_end_times += [(start_time, end_time, client_data_file) \
for (start_time, end_time) in client_data_list]
self.save_data(start_end_times)
def run(flow_mod_gap_ms):
util.ping_test()
switch = Switch(config.active_config)
switch.reset_flow_table()
control_client = ExpControlClient('mumu.ucsd.edu')
control_client.execute('RESET')
control_client.execute('SET auto_install_rules False')
control_client.execute('SET manual_install_gap_ms %s' % flow_mod_gap_ms)
control_client.execute('SET manual_install_active True')
# Send a starter packet to trigger packet-in. Doesn't matter what port it
# goes to, as long as it has the IP address of what would have been the
# pktgen host.
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.sendto('Hi', (config.active_config.source_ip, 12345))
# Let the whole system run for a while. We cannot check for TCAM status;
# that'd sometimes take forever when the switch is busily processing flow-
# mods, and it'd probably affect the flow-mods. We check the TCAM
# afterwards.
util.verbose_sleep(60)
control_client.execute('SET manual_install_active False')
# Gather stats about flow-mod. The flow-mod gap may not be accurate.
flow_mod_count = control_client.execute('GET flow_mod_count')
flow_mod_start_time = control_client.execute('GET flow_mod_start_time')
flow_mod_end_time = control_client.execute('GET flow_mod_end_time')
flow_mod_rate = flow_mod_count / (flow_mod_end_time - flow_mod_start_time)
# Wait for the switch to stabilize before asking it for stats.
util.verbose_sleep(80)
print 'Dumping table...'
# Parse flow tables. Search up to the last point of a TCAM-write, which
# signifies a full TCAM. Up to that point, we count the total number of
# rules added.
rule_list = switch.dump_tables(filter_str='')
tcam_rule_count = 0
total_rule_count = 0
print 'Parsing', len(rule_list), 'rules...'
for rule in rule_list:
total_rule_count += 1
if 'table_id=0' in rule:
tcam_rule_count += 1
if tcam_rule_count == 1500:
break
control_client.execute('RESET')
switch.reset_flow_table()
util.verbose_sleep(5)
return (tcam_rule_count, total_rule_count, flow_mod_rate)
def run(packet_size=1500):
# Writer initial header to file.
#result_file = './data/hp_sensitivity_%d_byte.csv' % packet_size # HP
#result_file = './data/evs_verify_sensitivity_%d_byte.csv' % packet_size # EVS
result_file = './data/monaco_sensitivity_%d_byte.csv' % packet_size # MONACO
with open(result_file, 'w') as f:
print >> f, 'ingress_pps,flow_mod_pps,pkt_out_pps,pkt_in_pps,rule_pps,egress_pps,expected_ingress,expected_flow_mod,expected_pkt_out'
#input_list = [10, 100, 400, 700, 1000] # HP
#input_list = [10, 100, 1000] # OVS
#input_list = [10, 100, 400, 700, 1000]
input_list = [10,30,100,320,330]
for ingress_pps in input_list:
for flow_mod_pps in input_list:
for pkt_out_pps in input_list:
# Ignore certain params. TODO: Debug.
# if packet_size == 1500:
# if _param_hash(ingress_pps, flow_mod_pps, pkt_out_pps) <= \
# _param_hash(400, 1000, 10):
# continue
for attempt in range(3):
try:
start_controller()
while True:
try:
proxy_client = StateProxyClient(FLEXI_CONTROLLER_HOST)
proxy_client.hello()
break
except:
print 'Waiting for controller...'
time.sleep(2)
proxy_client.reset()
print proxy_client.getall()
send_trigger_packet()
# Confirm trigger.
while not proxy_client.run('trigger_event_is_ready'):
print proxy_client.getall()
print 'Waiting for trigger...'
time.sleep(2)
# Set up the pkt generators
ingress = GenerateIngress(ingress_pps, proxy_client, packet_size=packet_size)
flow_mod = GenerateFlowMod(flow_mod_pps, proxy_client)
pkt_out = GeneratePktOut(pkt_out_pps, proxy_client, packet_size=packet_size)
# Set up pkt receivers.
pkt_in = ReceivePktIn(proxy_client)
check_rule = CheckRuleInstallationRate(proxy_client)
egress = ReceiveEgress(proxy_client)
print proxy_client.getall()
# Start receiving and sending.
for obj in [pkt_in, check_rule, egress, ingress, flow_mod, pkt_out]:
obj.start()
# Wait.
prompt = '(ingress_pps, flow_mod_pps, pkt_out_pps) = '
prompt += str((ingress_pps, flow_mod_pps, pkt_out_pps))
util.verbose_sleep(MAX_RUNNING_TIME, prompt)
# Stop sending and receiving.
for obj in [ingress, flow_mod, pkt_out, pkt_in, check_rule, egress]:
obj.stop()
# Gather data.
data_list = [ingress.get_sent_pps(),
flow_mod.get_sent_pps(),
pkt_out.get_sent_pps(),
pkt_in.get_received_pps(),
check_rule.get_received_pps(),
egress.get_received_pps(),
ingress_pps,
flow_mod_pps,
pkt_out_pps]
# Write csv data.
data = ','.join(['%.4f' % pps for pps in data_list])
with open(result_file, 'a') as f:
print >> f, data
print '*' * 80
print data
print '*' * 80
proxy_client.exit()
util.verbose_sleep(5, 'Waiting for the next experiment...')
break
except:
proxy_client.exit()
if attempt == 2:
raise
else:
with open('./data/CRASH.log', 'a') as crash_f:
print >> crash_f, traceback.format_exc()
