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 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()