def __gen_traffic(testbed_config, port_config_list, port_id, pause_flow_name, data_flow_name, prio, data_pkt_size, data_pkt_cnt, data_flow_delay_sec, exp_dur_sec, prio_dscp_map): """ Generate configurations of flows, including a data flow and a PFC pause storm. Args: testbed_config (obj): testbed L1/L2/L3 configuration port_config_list (list): list of port configuration port_id (int): ID of DUT port to test pause_flow_name (str): name of the pause storm data_flow_name (str): name of the data flow prio (int): priority of the data flow and PFC pause storm data_pkt_size (int): packet size of the data flow in byte data_pkt_cnt (int): # of packets of the data flow data_flow_delay_sec (float): start delay of the data flow in second exp_dur_sec (float): experiment duration in second prio_dscp_map (dict): Priority vs. DSCP map (key = priority). Returns: Configurations of the data flow and the PFC pause storm (list) """ result = list() rx_port_id = port_id tx_port_id_list, rx_port_id_list = select_ports( port_config_list=port_config_list, pattern="many to one", rx_port_id=rx_port_id) pytest_assert(len(tx_port_id_list) > 0, "Cannot find any TX ports") tx_port_id = select_tx_port(tx_port_id_list=tx_port_id_list, rx_port_id=rx_port_id) pytest_assert(tx_port_id is not None, "Cannot find a suitable TX port") tx_port_config = next((x for x in port_config_list if x.id == tx_port_id), None) rx_port_config = next((x for x in port_config_list if x.id == rx_port_id), None) tx_mac = tx_port_config.mac if tx_port_config.gateway == rx_port_config.gateway and \ tx_port_config.prefix_len == rx_port_config.prefix_len: """ If soruce and destination port are in the same subnet """ rx_mac = rx_port_config.mac else: rx_mac = tx_port_config.gateway_mac data_endpoint = PortTxRx( tx_port_name=testbed_config.ports[tx_port_id].name, rx_port_name=testbed_config.ports[rx_port_id].name) data_flow_delay_nanosec = sec_to_nanosec(data_flow_delay_sec) eth_hdr = EthernetHeader(src=FieldPattern(tx_mac), dst=FieldPattern(rx_mac), pfc_queue=FieldPattern([prio])) ip_prio = Priority( Dscp(phb=FieldPattern(choice=prio_dscp_map[prio]), ecn=FieldPattern(choice=Dscp.ECN_CAPABLE_TRANSPORT_1))) ipv4_hdr = Ipv4Header(src=FieldPattern(tx_port_config.ip), dst=FieldPattern(rx_port_config.ip), priority=ip_prio) data_flow = Flow(name=data_flow_name, tx_rx=TxRx(data_endpoint), packet=[Header(choice=eth_hdr), Header(choice=ipv4_hdr)], size=Size(data_pkt_size), rate=Rate('line', 100), duration=Duration( FixedPackets(packets=data_pkt_cnt, delay=data_flow_delay_nanosec, delay_unit='nanoseconds'))) result.append(data_flow) """ PFC Pause Storm """ pause_time = [] for x in range(8): if x == prio: pause_time.append('ffff') else: pause_time.append('0000') vector = pfc_class_enable_vector([prio]) pause_pkt = Header( PfcPause( dst=FieldPattern(choice='01:80:C2:00:00:01'), src=FieldPattern(choice='00:00:fa:ce:fa:ce'), class_enable_vector=FieldPattern(choice=vector), pause_class_0=FieldPattern(choice=pause_time[0]), pause_class_1=FieldPattern(choice=pause_time[1]), pause_class_2=FieldPattern(choice=pause_time[2]), pause_class_3=FieldPattern(choice=pause_time[3]), pause_class_4=FieldPattern(choice=pause_time[4]), pause_class_5=FieldPattern(choice=pause_time[5]), pause_class_6=FieldPattern(choice=pause_time[6]), pause_class_7=FieldPattern(choice=pause_time[7]), )) """ Pause frames are sent from the RX port """ pause_endpoint = PortTxRx( tx_port_name=testbed_config.ports[rx_port_id].name, rx_port_name=testbed_config.ports[tx_port_id].name) speed_str = testbed_config.layer1[0].speed speed_gbps = int(speed_str.split('_')[1]) pause_dur = 65535 * 64 * 8.0 / (speed_gbps * 1e9) pps = int(2 / pause_dur) pause_flow = Flow(name=pause_flow_name, tx_rx=TxRx(pause_endpoint), packet=[pause_pkt], size=Size(64), rate=Rate('pps', value=pps), duration=Duration( FixedSeconds(seconds=exp_dur_sec, delay=0, delay_unit='nanoseconds'))) result.append(pause_flow) return result
def __gen_traffic(testbed_config, port_id, pause_flow_name, global_pause, pause_prio_list, test_flow_name, test_flow_prio_list, test_flow_rate_percent, bg_flow_name, bg_flow_prio_list, bg_flow_rate_percent, data_flow_dur_sec, data_flow_delay_sec, data_pkt_size, prio_dscp_map): """ Generate configurations of flows, including test flows, background flows and pause storm. Test flows and background flows are also known as data flows. Args: testbed_config (obj): L2/L3 config of a T0 testbed port_id (int): ID of DUT port to test. pause_flow_name (str): name of pause storm global_pause (bool): if pause frame is IEEE 802.3X pause pause_prio_list (list): priorities to pause for pause frames test_flow_name (str): name of test flows test_prio_list (list): priorities of test flows test_flow_rate_percent (int): rate percentage for each test flow bg_flow_name (str): name of background flows bg_prio_list (list): priorities of background flows bg_flow_rate_percent (int): rate percentage for each background flow data_flow_dur_sec (int): duration of data flows in second data_flow_delay_sec (int): start delay of data flows in second data_pkt_size (int): packet size of data flows in byte prio_dscp_map (dict): Priority vs. DSCP map (key = priority). Returns: flows configurations (list): the list should have configurations of len(test_flow_prio_list) test flow, len(bg_flow_prio_list) background flows and a pause storm. """ result = list() rx_port_id = port_id tx_port_id = (port_id + 1) % len(testbed_config.devices) data_endpoint = DeviceTxRx( tx_device_names=[testbed_config.devices[tx_port_id].name], rx_device_names=[testbed_config.devices[rx_port_id].name], ) data_flow_delay_nanosec = sec_to_nanosec(data_flow_delay_sec) """ Test flows """ for prio in test_flow_prio_list: ip_prio = Priority( Dscp(phb=FieldPattern(choice=prio_dscp_map[prio]), ecn=FieldPattern(choice=Dscp.ECN_CAPABLE_TRANSPORT_1))) pfc_queue = FieldPattern([prio]) test_flow = Flow( name='{} Prio {}'.format(test_flow_name, prio), tx_rx=TxRx(data_endpoint), packet=[ Header(choice=EthernetHeader(pfc_queue=pfc_queue)), Header(choice=Ipv4Header(priority=ip_prio)) ], size=Size(data_pkt_size), rate=Rate('line', test_flow_rate_percent), duration=Duration( FixedSeconds(seconds=data_flow_dur_sec, delay=data_flow_delay_nanosec, delay_unit='nanoseconds'))) result.append(test_flow) """ Background flows """ for prio in bg_flow_prio_list: ip_prio = Priority( Dscp(phb=FieldPattern(choice=prio_dscp_map[prio]), ecn=FieldPattern(choice=Dscp.ECN_CAPABLE_TRANSPORT_1))) pfc_queue = FieldPattern([prio]) bg_flow = Flow(name='{} Prio {}'.format(bg_flow_name, prio), tx_rx=TxRx(data_endpoint), packet=[ Header(choice=EthernetHeader(pfc_queue=pfc_queue)), Header(choice=Ipv4Header(priority=ip_prio)) ], size=Size(data_pkt_size), rate=Rate('line', bg_flow_rate_percent), duration=Duration( FixedSeconds(seconds=data_flow_dur_sec, delay=data_flow_delay_nanosec, delay_unit='nanoseconds'))) result.append(bg_flow) """ Pause storm """ if global_pause: pause_pkt = Header( EthernetPause(dst=FieldPattern(choice='01:80:C2:00:00:01'), src=FieldPattern(choice='00:00:fa:ce:fa:ce'))) else: pause_time = [] for x in range(8): if x in pause_prio_list: pause_time.append('ffff') else: pause_time.append('0000') vector = pfc_class_enable_vector(pause_prio_list) pause_pkt = Header( PfcPause( dst=FieldPattern(choice='01:80:C2:00:00:01'), src=FieldPattern(choice='00:00:fa:ce:fa:ce'), class_enable_vector=FieldPattern(choice=vector), pause_class_0=FieldPattern(choice=pause_time[0]), pause_class_1=FieldPattern(choice=pause_time[1]), pause_class_2=FieldPattern(choice=pause_time[2]), pause_class_3=FieldPattern(choice=pause_time[3]), pause_class_4=FieldPattern(choice=pause_time[4]), pause_class_5=FieldPattern(choice=pause_time[5]), pause_class_6=FieldPattern(choice=pause_time[6]), pause_class_7=FieldPattern(choice=pause_time[7]), )) """ Pause frames are sent from the RX port """ pause_src_point = PortTxRx( tx_port_name=testbed_config.ports[rx_port_id].name, rx_port_name=testbed_config.ports[tx_port_id].name) speed_str = testbed_config.layer1[0].speed speed_gbps = int(speed_str.split('_')[1]) pause_dur = 65535 * 64 * 8.0 / (speed_gbps * 1e9) pps = int(2 / pause_dur) pause_flow = Flow(name=pause_flow_name, tx_rx=TxRx(pause_src_point), packet=[pause_pkt], size=Size(64), rate=Rate('pps', value=pps), duration=Duration( Continuous(delay=0, delay_unit='nanoseconds'))) result.append(pause_flow) return result
def _pfc_watch_dog_config(pi): vlan_subnet = get_vlan_subnet(duthost) pytest_assert(vlan_subnet is not None, "Fail to get Vlan subnet information") vlan_ip_addrs = get_addrs_in_subnet(vlan_subnet, 3) gw_addr = vlan_subnet.split('/')[0] interface_ip_addr = vlan_ip_addrs[0] device1_ip = vlan_ip_addrs[0] device2_ip = vlan_ip_addrs[1] device3_ip = vlan_ip_addrs[2] device1_gateway_ip = gw_addr device2_gateway_ip = gw_addr device3_gateway_ip = gw_addr config = one_hundred_gbe.create_config() line_rate = pfcwd_params['traffic_line_rate'] pause_line_rate = pfcwd_params['pause_line_rate'] start_delay = pfcwd_params['start_delay'] frame_size = pfcwd_params['frame_size'] t_start_pause = pfcwd_params['t_start_pause'] ###################################################################### # Device Configuration ###################################################################### port1 = config.ports[0] port2 = config.ports[1] port3 = config.ports[2] #Device 1 configuration port1.devices = [ Device(name='Port 1', device_count=1, choice=Ipv4(name='Ipv4 1', address=Pattern(device1_ip), prefix=Pattern('24'), gateway=Pattern(device1_gateway_ip), ethernet=Ethernet(name='Ethernet 1'))) ] #Device 2 configuration port2.devices = [ Device(name='Port 2', device_count=1, choice=Ipv4(name='Ipv4 2', address=Pattern(device2_ip), prefix=Pattern('24'), gateway=Pattern(device2_gateway_ip), ethernet=Ethernet(name='Ethernet 2'))) ] #Device 3 configuration port3.devices = [ Device(name='Port 3', device_count=1, choice=Ipv4(name='Ipv4 3', address=Pattern(device3_ip), prefix=Pattern('24'), gateway=Pattern(device3_gateway_ip), ethernet=Ethernet(name='Ethernet 3'))) ] device1 = port1.devices[0] device2 = port2.devices[0] device3 = port3.devices[0] ###################################################################### # Traffic configuration Traffic 1->2 ###################################################################### dscp_pi = Priority(Dscp(phb=FieldPattern(choice=[str(pi)]))) flow_1to2 = Flow(name="Traffic 1->2", tx_rx=TxRx( DeviceTxRx(tx_device_names=[device1.name], rx_device_names=[device2.name])), packet=[ Header(choice=EthernetHeader()), Header(choice=Ipv4Header(priority=dscp_pi)), ], size=Size(frame_size), rate=Rate('line', line_rate), duration=Duration( Continuous(delay=start_delay, delay_unit='nanoseconds'))) config.flows.append(flow_1to2) ###################################################################### # Traffic configuration Traffic 2->1 ###################################################################### flow_2to1 = Flow(name="Traffic 2->1", tx_rx=TxRx( DeviceTxRx(tx_device_names=[device2.name], rx_device_names=[device1.name])), packet=[ Header(choice=EthernetHeader()), Header(choice=Ipv4Header(priority=dscp_pi)), ], size=Size(frame_size), rate=Rate('line', line_rate), duration=Duration( Continuous(delay=start_delay, delay_unit='nanoseconds'))) config.flows.append(flow_2to1) ###################################################################### # Traffic configuration Traffic 2->3 ####################################################################### flow_2to3 = Flow(name="Traffic 2->3", tx_rx=TxRx( DeviceTxRx(tx_device_names=[device2.name], rx_device_names=[device3.name])), packet=[ Header(choice=EthernetHeader()), Header(choice=Ipv4Header(priority=dscp_pi)), ], size=Size(frame_size), rate=Rate('line', line_rate), duration=Duration( Continuous(delay=start_delay, delay_unit='nanoseconds'))) config.flows.append(flow_2to3) ###################################################################### # Traffic configuration Traffic 3->2 ####################################################################### flow_3to2 = Flow(name="Traffic 3->2", tx_rx=TxRx( DeviceTxRx(tx_device_names=[device3.name], rx_device_names=[device2.name])), packet=[ Header(choice=EthernetHeader()), Header(choice=Ipv4Header(priority=dscp_pi)), ], size=Size(frame_size), rate=Rate('line', line_rate), duration=Duration( Continuous(delay=start_delay, delay_unit='nanoseconds'))) config.flows.append(flow_3to2) ####################################################################### # Traffic configuration Pause ####################################################################### if (pi == 3): pause = Header( PfcPause( dst=FieldPattern(choice='01:80:C2:00:00:01'), src=FieldPattern(choice='00:00:fa:ce:fa:ce'), class_enable_vector=FieldPattern(choice='8'), pause_class_0=FieldPattern(choice='0'), pause_class_1=FieldPattern(choice='0'), pause_class_2=FieldPattern(choice='0'), pause_class_3=FieldPattern(choice='ffff'), pause_class_4=FieldPattern(choice='0'), pause_class_5=FieldPattern(choice='0'), pause_class_6=FieldPattern(choice='0'), pause_class_7=FieldPattern(choice='0'), )) elif (pi == 4): pause = Header( PfcPause( dst=FieldPattern(choice='01:80:C2:00:00:01'), src=FieldPattern(choice='00:00:fa:ce:fa:ce'), class_enable_vector=FieldPattern(choice='10'), pause_class_0=FieldPattern(choice='0'), pause_class_1=FieldPattern(choice='0'), pause_class_2=FieldPattern(choice='0'), pause_class_3=FieldPattern(choice='0'), pause_class_4=FieldPattern(choice='ffff'), pause_class_5=FieldPattern(choice='0'), pause_class_6=FieldPattern(choice='0'), pause_class_7=FieldPattern(choice='0'), )) else: pytest_assert( False, "This testcase supports only lossless priorities 3 & 4") pause_flow = Flow(name='Pause Storm', tx_rx=TxRx( PortTxRx(tx_port_name=port3.name, rx_port_names=[port3.name])), packet=[pause], size=Size(64), rate=Rate('line', value=pause_line_rate), duration=Duration( Continuous(delay=t_start_pause * (10**9), delay_unit='nanoseconds'))) config.flows.append(pause_flow) return config
def base_configs(testbed, conn_graph_facts, duthost, lossless_prio_dscp_map, one_hundred_gbe, start_delay, pause_line_rate, traffic_line_rate, frame_size, ecn_thresholds, serializer): for config in one_hundred_gbe: start_delay = start_delay * 1000000000.0 test_dscp_list = [str(prio) for prio in lossless_prio_dscp_map] tx = config.ports[0] rx = config.ports[1] vlan_subnet = get_vlan_subnet(duthost) pytest_assert(vlan_subnet is not None, "Fail to get Vlan subnet information") vlan_ip_addrs = get_addrs_in_subnet(vlan_subnet, 2) gw_addr = vlan_subnet.split('/')[0] interface_ip_addr = vlan_ip_addrs[0] tx_port_ip = vlan_ip_addrs[1] rx_port_ip = vlan_ip_addrs[0] tx_gateway_ip = gw_addr rx_gateway_ip = gw_addr test_flow_name = 'Test Data' test_line_rate = traffic_line_rate pause_line_rate = pause_line_rate pytest_assert(test_line_rate <= pause_line_rate, "test_line_rate + should be less than pause_line_rate") ###################################################################### # Create TX stack configuration ###################################################################### tx_ipv4 = Ipv4(name='Tx Ipv4', address=Pattern(tx_port_ip), prefix=Pattern('24'), gateway=Pattern(tx_gateway_ip), ethernet=Ethernet(name='Tx Ethernet')) tx.devices.append( Device(name='Tx Device', device_count=1, choice=tx_ipv4)) ###################################################################### # Create RX stack configuration ###################################################################### rx_ipv4 = Ipv4(name='Rx Ipv4', address=Pattern(rx_port_ip), prefix=Pattern('24'), gateway=Pattern(rx_gateway_ip), ethernet=Ethernet(name='Rx Ethernet')) rx.devices.append( Device(name='Rx Device', device_count=1, choice=rx_ipv4)) ###################################################################### # Traffic configuration Test data ###################################################################### data_endpoint = DeviceTxRx( tx_device_names=[tx.devices[0].name], rx_device_names=[rx.devices[0].name], ) pytest_assert(ecn_thresholds < 1024 * 1024, "keep the ECN thresholds less than 1MB") test_dscp = Priority( Dscp(phb=FieldPattern(choice=test_dscp_list), ecn=FieldPattern(Dscp.ECN_CAPABLE_TRANSPORT_1))) # ecn_thresholds in bytes number_of_packets = int(2 * (ecn_thresholds / frame_size)) logger.info("Total number of packets to send = 2 * %s = %s"\ %(ecn_thresholds / frame_size, number_of_packets)) test_flow = Flow(name=test_flow_name, tx_rx=TxRx(data_endpoint), packet=[ Header(choice=EthernetHeader()), Header(choice=Ipv4Header(priority=test_dscp)) ], size=Size(frame_size), rate=Rate('line', test_line_rate), duration=Duration( FixedPackets(packets=number_of_packets, delay=start_delay, delay_unit='nanoseconds'))) config.flows.append(test_flow) ####################################################################### # Traffic configuration Pause ####################################################################### pause_endpoint = PortTxRx(tx_port_name='Rx', rx_port_names=['Rx']) pause = Header( PfcPause( dst=FieldPattern(choice='01:80:C2:00:00:01'), src=FieldPattern(choice='00:00:fa:ce:fa:ce'), class_enable_vector=FieldPattern(choice='18'), pause_class_0=FieldPattern(choice='0'), pause_class_1=FieldPattern(choice='0'), pause_class_2=FieldPattern(choice='0'), pause_class_3=FieldPattern(choice='ffff'), pause_class_4=FieldPattern(choice='ffff'), pause_class_5=FieldPattern(choice='0'), pause_class_6=FieldPattern(choice='0'), pause_class_7=FieldPattern(choice='0'), )) pause_flow = Flow(name='Pause Storm', tx_rx=TxRx(pause_endpoint), packet=[pause], size=Size(64), rate=Rate('line', value=100), duration=Duration( FixedPackets(packets=0, delay=0, delay_unit='nanoseconds'))) config.flows.append(pause_flow) return one_hundred_gbe