Re: [dpdk-dev] [PATCH v2] ADD mode 5(tlb) to link bonding pmd

["Doherty, Declan" <declan.doherty@intel.com>]

> -----Original Message-----
> From: dev [mailto:dev-bounces@dpdk.org] On Behalf Of Daniel Mrzyglod
> Sent: Friday, September 26, 2014 4:41 PM
> To: dev@dpdk.org
> Subject: [dpdk-dev] [PATCH v2] ADD mode 5(tlb) to link bonding pmd
> 
> 
> Signed-off-by: Daniel Mrzyglod <danielx.t.mrzyglod@intel.com>
> ---
>  app/test/test_link_bonding.c               |  501 +++++++++++++++++++++++++++-
>  app/test/virtual_pmd.c                     |    6 +-
>  app/test/virtual_pmd.h                     |    7 +
>  lib/librte_pmd_bond/rte_eth_bond.h         |   23 ++
>  lib/librte_pmd_bond/rte_eth_bond_args.c    |    1 +
>  lib/librte_pmd_bond/rte_eth_bond_pmd.c     |  161 ++++++++-
>  lib/librte_pmd_bond/rte_eth_bond_private.h |    3 +-
>  7 files changed, 696 insertions(+), 6 deletions(-)
> 
> diff --git a/app/test/test_link_bonding.c b/app/test/test_link_bonding.c
> index c4fcaf7..77f791f 100644
> --- a/app/test/test_link_bonding.c
> +++ b/app/test/test_link_bonding.c
> @@ -41,7 +41,7 @@
>  #include <errno.h>
>  #include <sys/queue.h>
>  #include <sys/time.h>
> -
> +#include <rte_cycles.h>
>  #include <rte_byteorder.h>
>  #include <rte_common.h>
>  #include <rte_debug.h>
> @@ -3845,6 +3845,500 @@ testsuite_teardown(void)
>  	return remove_slaves_and_stop_bonded_device();
>  }
> 
> +#define NINETY_PERCENT_NUMERAL 90
> +#define ONE_HUNDRED_PERCENT_DENOMINATOR 100
> +#define ONE_HUNDRED_PERCENT_AND_TEN_NUMERAL 110
> +static int
> +test_tlb_tx_burst(void)
> +{
> +	int i, burst_size, nb_tx;
> +	uint64_t nb_tx2 = 0;
> +	struct rte_mbuf *pkt_burst[MAX_PKT_BURST];
> +	struct rte_eth_stats port_stats[32];
> +	uint64_t sum_ports_opackets = 0, all_bond_opackets = 0,
> all_bond_obytes = 0;
> +	uint16_t pktlen;
> +
> +	TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves
> +
> 	(BONDING_MODE_ADAPTIVE_TRANSMIT_LOAD_BALANCING, 1, 3, 1),
> +			"Failed to initialise bonded device");
> +
> +	burst_size = 20 * test_params->bonded_slave_count;
> +
> +	TEST_ASSERT(burst_size < MAX_PKT_BURST,
> +			"Burst size specified is greater than supported.\n");
> +
> +
> +	/* Generate 400000 test bursts in 2s of packets to transmit  */
> +	for (i = 0; i < 400000; i++) {
> +		/*test two types of mac src own(bonding) and others */
> +		if (i % 2 == 0) {
> +			initialize_eth_header(test_params->pkt_eth_hdr,
> +					(struct ether_addr *)src_mac, (struct
> ether_addr *)dst_mac_0, 0, 0);
> +		} else {
> +			initialize_eth_header(test_params->pkt_eth_hdr,
> +					(struct ether_addr *)test_params-
> >default_slave_mac,
> +					(struct ether_addr *)dst_mac_0, 0, 0);
> +		}
> +		pktlen = initialize_udp_header(test_params->pkt_udp_hdr,
> src_port,
> +				dst_port_0, 16);
> +		pktlen = initialize_ipv4_header(test_params->pkt_ipv4_hdr,
> src_addr,
> +				dst_addr_0, pktlen);
> +		generate_packet_burst(test_params->mbuf_pool, pkt_burst,
> +				test_params->pkt_eth_hdr, 0, test_params-
> >pkt_ipv4_hdr,
> +				1, test_params->pkt_udp_hdr, burst_size, 60, 1);
> +		/* Send burst on bonded port */
> +		nb_tx = rte_eth_tx_burst(test_params->bonded_port_id, 0,
> pkt_burst,
> +				burst_size);
> +		nb_tx2 += nb_tx;
> +
> +		TEST_ASSERT_EQUAL(nb_tx, burst_size,
> +				"number of packet not equal burst size");
> +
> +		rte_delay_us(5);
> +	}
> +
> +
> +	/* Verify bonded port tx stats */
> +	rte_eth_stats_get(test_params->bonded_port_id, &port_stats[0]);
> +
> +	all_bond_opackets = port_stats[0].opackets;
> +	all_bond_obytes = port_stats[0].obytes;
> +
> +	TEST_ASSERT_EQUAL(port_stats[0].opackets, (uint64_t)nb_tx2,
> +			"Bonded Port (%d) opackets value (%u) not as expected
> (%d)\n",
> +			test_params->bonded_port_id, (unsigned
> int)port_stats[0].opackets,
> +			burst_size);
> +
> +
> +	/* Verify slave ports tx stats */
> +	for (i = 0; i < test_params->bonded_slave_count; i++) {
> +		rte_eth_stats_get(test_params->slave_port_ids[i], &port_stats[i]);
> +		sum_ports_opackets += port_stats[i].opackets;
> +	}
> +
> +	TEST_ASSERT_EQUAL(sum_ports_opackets, (uint64_t)all_bond_opackets,
> +			"Total packets sent by slaves is not equalto packets sent by
> bond interface");
> +
> +	for (i = 0; i < test_params->bonded_slave_count; i++) {
> +		printf("port stats:%"PRIu64"\n", port_stats[i].opackets);
> +		/* distribution of packets on each slave within +/- 10% of the
> expected value. */
> +		TEST_ASSERT(port_stats[i].obytes >=
> ((all_bond_obytes*NINETY_PERCENT_NUMERAL)/
> +				(test_params-
> >bonded_slave_count*ONE_HUNDRED_PERCENT_DENOMINATOR)) &&
> +				port_stats[i].obytes <=
> ((all_bond_obytes*ONE_HUNDRED_PERCENT_AND_TEN_NUMERAL) /
> +						(test_params-
> >bonded_slave_count*ONE_HUNDRED_PERCENT_DENOMINATOR)),
> +						"Distribution is not even");
> +	}
> +	/* Put all slaves down and try and transmit */
> +	for (i = 0; i < test_params->bonded_slave_count; i++) {
> +		virtual_ethdev_simulate_link_status_interrupt(
> +				test_params->slave_port_ids[i], 0);
> +	}
> +
> +	/* Send burst on bonded port */
> +	nb_tx = rte_eth_tx_burst(test_params->bonded_port_id, 0, pkt_burst,
> +			burst_size);
> +	TEST_ASSERT_EQUAL(nb_tx, 0, " bad number of packet in burst");
> +
> +	/* Clean ugit checkout masterp and remove slaves from bonded device */
> +	return remove_slaves_and_stop_bonded_device();
> +}
> +
> +#define
> TEST_ADAPTIVE_TRANSMIT_LOAD_BALANCING_RX_BURST_SLAVE_COUNT (4)
> +
> +static int
> +test_tlb_rx_burst(void)
> +{
> +	struct rte_mbuf *gen_pkt_burst[MAX_PKT_BURST] = { NULL };
> +	struct rte_mbuf *rx_pkt_burst[MAX_PKT_BURST] = { NULL };
> +
> +	struct rte_eth_stats port_stats;
> +
> +	int primary_port;
> +
> +	uint16_t i, j, nb_rx, burst_size = 17;
> +
> +	/* Initialize bonded device with 4 slaves in transmit load balancing mode
> */
> +	TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves(
> +
> 	BONDING_MODE_ADAPTIVE_TRANSMIT_LOAD_BALANCING,
> +
> 	TEST_ADAPTIVE_TRANSMIT_LOAD_BALANCING_RX_BURST_SLAVE_COUNT
> , 1, 1),
> +			"Failed to initialize bonded device");
> +
> +
> +	primary_port = rte_eth_bond_primary_get(test_params-
> >bonded_port_id);
> +	TEST_ASSERT(primary_port >= 0,
> +			"failed to get primary slave for bonded port (%d)",
> +			test_params->bonded_port_id);
> +
> +	for (i = 0; i < test_params->bonded_slave_count; i++) {
> +		/* Generate test bursts of packets to transmit */
> +		TEST_ASSERT_EQUAL(generate_test_burst(
> +				&gen_pkt_burst[0], burst_size, 0, 1, 0, 0, 0),
> burst_size,
> +				"burst generation failed");
> +
> +		/* Add rx data to slave */
> +		virtual_ethdev_add_mbufs_to_rx_queue(test_params-
> >slave_port_ids[i],
> +				&gen_pkt_burst[0], burst_size);
> +
> +		/* Call rx burst on bonded device */
> +		nb_rx = rte_eth_rx_burst(test_params->bonded_port_id, 0,
> +				&rx_pkt_burst[0], MAX_PKT_BURST);
> +
> +		TEST_ASSERT_EQUAL(nb_rx,burst_size,"rte_eth_rx_burst
> failed\n");
> +
> +		if (test_params->slave_port_ids[i] == primary_port) {
> +			/* Verify bonded device rx count */
> +			rte_eth_stats_get(test_params->bonded_port_id,
> &port_stats);
> +			TEST_ASSERT_EQUAL(port_stats.ipackets,
> (uint64_t)burst_size,
> +					"Bonded Port (%d) ipackets value (%u) not
> as expected (%d)\n",
> +					test_params->bonded_port_id,
> +					(unsigned int)port_stats.ipackets,
> burst_size);
> +
> +			/* Verify bonded slave devices rx count */
> +			for (j = 0; j < test_params->bonded_slave_count; j++) {
> +				rte_eth_stats_get(test_params->slave_port_ids[j],
> &port_stats);
> +				if (i == j) {
> +					TEST_ASSERT_EQUAL(port_stats.ipackets,
> (uint64_t)burst_size,
> +							"Slave Port (%d) ipackets
> value (%u) not as expected (%d)\n",
> +							test_params-
> >slave_port_ids[i],
> +							(unsigned
> int)port_stats.ipackets, burst_size);
> +				} else {
> +					TEST_ASSERT_EQUAL(port_stats.ipackets,
> (uint64_t)0,
> +							"Slave Port (%d) ipackets
> value (%u) not as expected (%d)\n",
> +							test_params-
> >slave_port_ids[i],
> +							(unsigned
> int)port_stats.ipackets, 0);
> +				}
> +			}
> +		} else {
> +			for (j = 0; j < test_params->bonded_slave_count; j++) {
> +				rte_eth_stats_get(test_params->slave_port_ids[j],
> &port_stats);
> +				TEST_ASSERT_EQUAL(port_stats.ipackets,
> (uint64_t)0,
> +						"Slave Port (%d) ipackets value
> (%u) not as expected (%d)\n",
> +						test_params->slave_port_ids[i],
> +						(unsigned int)port_stats.ipackets,
> 0);
> +			}
> +		}
> +
> +		/* free mbufs */
> +		for (i = 0; i < burst_size; i++)
> +			rte_pktmbuf_free(rx_pkt_burst[i]);
> +
> +		/* reset bonded device stats */
> +		rte_eth_stats_reset(test_params->bonded_port_id);
> +	}
> +
> +	/* Clean up and remove slaves from bonded device */
> +	return remove_slaves_and_stop_bonded_device();
> +}
> +
> +static int
> +test_tlb_verify_promiscuous_enable_disable(void)
> +{
> +	int i, primary_port, promiscuous_en;
> +
> +	/* Initialize bonded device with 4 slaves in transmit load balancing mode
> */
> +	TEST_ASSERT_SUCCESS( initialize_bonded_device_with_slaves(
> +
> 	BONDING_MODE_ADAPTIVE_TRANSMIT_LOAD_BALANCING, 0, 4, 1),
> +			"Failed to initialize bonded device");
> +
> +	primary_port = rte_eth_bond_primary_get(test_params-
> >bonded_port_id);
> +	TEST_ASSERT(primary_port >= 0,
> +			"failed to get primary slave for bonded port (%d)",
> +			test_params->bonded_port_id);
> +
> +	rte_eth_promiscuous_enable(test_params->bonded_port_id);
> +
> +	promiscuous_en = rte_eth_promiscuous_get(test_params-
> >bonded_port_id);
> +	TEST_ASSERT_EQUAL(promiscuous_en, (int)1,
> +			"Port (%d) promiscuous mode not enabled\n",
> +			test_params->bonded_port_id);
> +	for (i = 0; i < test_params->bonded_slave_count; i++) {
> +		promiscuous_en = rte_eth_promiscuous_get(
> +				test_params->slave_port_ids[i]);
> +		if (primary_port == test_params->slave_port_ids[i]) {
> +			TEST_ASSERT_EQUAL(promiscuous_en, (int)1,
> +					"Port (%d) promiscuous mode not
> enabled\n",
> +					test_params->bonded_port_id);
> +		} else {
> +			TEST_ASSERT_EQUAL(promiscuous_en, (int)0,
> +					"Port (%d) promiscuous mode enabled\n",
> +					test_params->bonded_port_id);
> +		}
> +
> +	}
> +
> +	rte_eth_promiscuous_disable(test_params->bonded_port_id);
> +
> +	promiscuous_en = rte_eth_promiscuous_get(test_params-
> >bonded_port_id);
> +	TEST_ASSERT_EQUAL(promiscuous_en, (int)0,
> +			"Port (%d) promiscuous mode not disabled\n",
> +			test_params->bonded_port_id);
> +
> +	for (i = 0; i < test_params->bonded_slave_count; i++) {
> +		promiscuous_en = rte_eth_promiscuous_get(
> +				test_params->slave_port_ids[i]);
> +		TEST_ASSERT_EQUAL(promiscuous_en, (int)0,
> +				"slave port (%d) promiscuous mode not
> disabled\n",
> +				test_params->slave_port_ids[i]);
> +	}
> +
> +	/* Clean up and remove slaves from bonded device */
> +	return remove_slaves_and_stop_bonded_device();
> +}
> +
> +static int
> +test_tlb_verify_mac_assignment(void)
> +{
> +	struct ether_addr read_mac_addr, expected_mac_addr_0,
> expected_mac_addr_1;
> +
> +	rte_eth_macaddr_get(test_params->slave_port_ids[0],
> &expected_mac_addr_0);
> +	rte_eth_macaddr_get(test_params->slave_port_ids[1],
> &expected_mac_addr_1);
> +
> +	/* Initialize bonded device with 2 slaves in active backup mode */
> +	TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves(
> +
> 	BONDING_MODE_ADAPTIVE_TRANSMIT_LOAD_BALANCING, 0, 2, 1),
> +			"Failed to initialize bonded device");
> +
> +	/* Verify that bonded MACs is that of first slave and that the other slave
> +	 * MAC hasn't been changed */
> +	rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr);
> +	TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0,
> &read_mac_addr,
> +			sizeof(read_mac_addr)),
> +			"bonded port (%d) mac address not set to that of primary
> port",
> +			test_params->bonded_port_id);
> +
> +	rte_eth_macaddr_get(test_params->slave_port_ids[0],
> &read_mac_addr);
> +	TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0,
> &read_mac_addr,
> +			sizeof(read_mac_addr)),
> +			"slave port (%d) mac address not set to that of primary
> port",
> +			test_params->slave_port_ids[0]);
> +
> +	rte_eth_macaddr_get(test_params->slave_port_ids[1],
> &read_mac_addr);
> +	TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_1,
> &read_mac_addr,
> +			sizeof(read_mac_addr)),
> +			"slave port (%d) mac address not as expected",
> +			test_params->slave_port_ids[1]);
> +
> +	/* change primary and verify that MAC addresses haven't changed */
> +	TEST_ASSERT_EQUAL(rte_eth_bond_primary_set(test_params-
> >bonded_port_id,
> +			test_params->slave_port_ids[1]), 0,
> +			"Failed to set bonded port (%d) primary port to (%d)",
> +			test_params->bonded_port_id, test_params-
> >slave_port_ids[1]);
> +
> +	rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr);
> +	TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0,
> &read_mac_addr,
> +			sizeof(read_mac_addr)),
> +			"bonded port (%d) mac address not set to that of primary
> port",
> +			test_params->bonded_port_id);
> +
> +	rte_eth_macaddr_get(test_params->slave_port_ids[0],
> &read_mac_addr);
> +	TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0,
> &read_mac_addr,
> +			sizeof(read_mac_addr)),
> +			"slave port (%d) mac address not set to that of primary
> port",
> +			test_params->slave_port_ids[0]);
> +
> +	rte_eth_macaddr_get(test_params->slave_port_ids[1],
> &read_mac_addr);
> +	TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_1,
> &read_mac_addr,
> +			sizeof(read_mac_addr)),
> +			"slave port (%d) mac address not as expected",
> +			test_params->slave_port_ids[1]);
> +
> +	/* stop / start bonded device and verify that primary MAC address is
> +	 * propagated to bonded device and slaves */
> +
> +	rte_eth_dev_stop(test_params->bonded_port_id);
> +
> +	TEST_ASSERT_SUCCESS(rte_eth_dev_start(test_params-
> >bonded_port_id),
> +			"Failed to start device");
> +
> +	rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr);
> +	TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_1,
> &read_mac_addr,
> +			sizeof(read_mac_addr)),
> +			"bonded port (%d) mac address not set to that of primary
> port",
> +			test_params->bonded_port_id);
> +
> +	rte_eth_macaddr_get(test_params->slave_port_ids[0],
> &read_mac_addr);
> +	TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0,
> &read_mac_addr,
> +			sizeof(read_mac_addr)),
> +			"slave port (%d) mac address not as expected",
> +			test_params->slave_port_ids[0]);
> +
> +	rte_eth_macaddr_get(test_params->slave_port_ids[1],
> &read_mac_addr);
> +	TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_1,
> &read_mac_addr,
> +			sizeof(read_mac_addr)),
> +			"slave port (%d) mac address not set to that of primary
> port",
> +			test_params->slave_port_ids[1]);
> +
> +
> +	/* Set explicit MAC address */
> +	TEST_ASSERT_SUCCESS(rte_eth_bond_mac_address_set(
> +			test_params->bonded_port_id, (struct ether_addr
> *)bonded_mac),
> +			"failed to set MAC addres");
> +
> +	rte_eth_macaddr_get(test_params->bonded_port_id, &read_mac_addr);
> +	TEST_ASSERT_SUCCESS(memcmp(&bonded_mac, &read_mac_addr,
> +			sizeof(read_mac_addr)),
> +			"bonded port (%d) mac address not set to that of bonded
> port",
> +			test_params->bonded_port_id);
> +
> +	rte_eth_macaddr_get(test_params->slave_port_ids[0],
> &read_mac_addr);
> +	TEST_ASSERT_SUCCESS(memcmp(&expected_mac_addr_0,
> &read_mac_addr,
> +			sizeof(read_mac_addr)),
> +			"slave port (%d) mac address not as expected",
> +			test_params->slave_port_ids[0]);
> +
> +	rte_eth_macaddr_get(test_params->slave_port_ids[1],
> &read_mac_addr);
> +	TEST_ASSERT_SUCCESS(memcmp(&bonded_mac, &read_mac_addr,
> +			sizeof(read_mac_addr)),
> +			"slave port (%d) mac address not set to that of bonded
> port",
> +			test_params->slave_port_ids[1]);
> +
> +	/* Clean up and remove slaves from bonded device */
> +	return remove_slaves_and_stop_bonded_device();
> +}
> +
> +static int
> +test_tlb_verify_slave_link_status_change_failover(void)
> +{
> +	struct rte_mbuf
> *pkt_burst[TEST_ADAPTIVE_TRANSMIT_LOAD_BALANCING_RX_BURST_SLAVE_CO
> UNT][MAX_PKT_BURST];
> +	struct rte_mbuf *rx_pkt_burst[MAX_PKT_BURST] = { NULL };
> +	struct rte_eth_stats port_stats;
> +
> +	uint8_t slaves[RTE_MAX_ETHPORTS];
> +
> +	int i, j, burst_size, slave_count, primary_port;
> +
> +	burst_size = 21;
> +
> +	memset(pkt_burst, 0, sizeof(pkt_burst));
> +
> +
> +
> +	/* Initialize bonded device with 4 slaves in round robin mode */
> +	TEST_ASSERT_SUCCESS(initialize_bonded_device_with_slaves(
> +
> 	BONDING_MODE_ADAPTIVE_TRANSMIT_LOAD_BALANCING, 0,
> +
> 	TEST_ADAPTIVE_TRANSMIT_LOAD_BALANCING_RX_BURST_SLAVE_COUNT
> , 1),
> +			"Failed to initialize bonded device with slaves");
> +
> +	/* Verify Current Slaves Count /Active Slave Count is */
> +	slave_count = rte_eth_bond_slaves_get(test_params->bonded_port_id,
> slaves,
> +			RTE_MAX_ETHPORTS);
> +	TEST_ASSERT_EQUAL(slave_count, 4,
> +			"Number of slaves (%d) is not as expected (%d).\n",
> +			slave_count, 4);
> +
> +	slave_count = rte_eth_bond_active_slaves_get(test_params-
> >bonded_port_id,
> +			slaves, RTE_MAX_ETHPORTS);
> +	TEST_ASSERT_EQUAL(slave_count, (int)4,
> +			"Number of slaves (%d) is not as expected (%d).\n",
> +			slave_count, 4);
> +
> +	primary_port = rte_eth_bond_primary_get(test_params-
> >bonded_port_id);
> +	TEST_ASSERT_EQUAL(primary_port, test_params->slave_port_ids[0],
> +			"Primary port not as expected");
> +
> +	/* Bring 2 slaves down and verify active slave count */
> +	virtual_ethdev_simulate_link_status_interrupt(
> +			test_params->slave_port_ids[1], 0);
> +	virtual_ethdev_simulate_link_status_interrupt(
> +			test_params->slave_port_ids[3], 0);
> +
> +	TEST_ASSERT_EQUAL(rte_eth_bond_active_slaves_get(
> +			test_params->bonded_port_id, slaves,
> RTE_MAX_ETHPORTS), 2,
> +			"Number of active slaves (%d) is not as expected (%d).",
> +			slave_count, 2);
> +
> +	virtual_ethdev_simulate_link_status_interrupt(
> +			test_params->slave_port_ids[1], 1);
> +	virtual_ethdev_simulate_link_status_interrupt(
> +			test_params->slave_port_ids[3], 1);
> +
> +
> +	/* Bring primary port down, verify that active slave count is 3 and primary
> +	 *  has changed */
> +	virtual_ethdev_simulate_link_status_interrupt(
> +			test_params->slave_port_ids[0], 0);
> +
> +	TEST_ASSERT_EQUAL(rte_eth_bond_active_slaves_get(
> +			test_params->bonded_port_id, slaves,
> RTE_MAX_ETHPORTS), 3,
> +			"Number of active slaves (%d) is not as expected (%d).",
> +			slave_count, 3);
> +
> +	primary_port = rte_eth_bond_primary_get(test_params-
> >bonded_port_id);
> +	TEST_ASSERT_EQUAL(primary_port, test_params->slave_port_ids[2],
> +			"Primary port not as expected");
> +	rte_delay_us(500000);
> +	/* Verify that pkts are sent on new primary slave */
> +	for (i = 0; i < 4; i++) {
> +		TEST_ASSERT_EQUAL(generate_test_burst(
> +				&pkt_burst[0][0], burst_size, 0, 1, 0, 0, 0),
> burst_size,
> +				"generate_test_burst failed\n");
> +		TEST_ASSERT_EQUAL(rte_eth_tx_burst(
> +				test_params->bonded_port_id, 0,
> &pkt_burst[0][0], burst_size), burst_size,
> +				"rte_eth_tx_burst failed\n");
> +		rte_delay_us(11000);
> +	}
> +
> +	rte_eth_stats_get(test_params->slave_port_ids[2], &port_stats);
> +	TEST_ASSERT_NOT_EQUAL(port_stats.opackets, (int8_t)0,
> +			"(%d) port_stats.opackets not as expected\n",
> +			test_params->slave_port_ids[2]);
> +
> +	rte_eth_stats_get(test_params->slave_port_ids[0], &port_stats);
> +	TEST_ASSERT_EQUAL(port_stats.opackets, (int8_t)0,
> +			"(%d) port_stats.opackets not as expected\n",
> +			test_params->slave_port_ids[0]);
> +
> +	rte_eth_stats_get(test_params->slave_port_ids[1], &port_stats);
> +	TEST_ASSERT_NOT_EQUAL(port_stats.opackets, (int8_t)0,
> +			"(%d) port_stats.opackets not as expected\n",
> +			test_params->slave_port_ids[1]);
> +
> +	rte_eth_stats_get(test_params->slave_port_ids[3], &port_stats);
> +	TEST_ASSERT_NOT_EQUAL(port_stats.opackets, (int8_t)0,
> +			"(%d) port_stats.opackets not as expected\n",
> +			test_params->slave_port_ids[3]);
> +
> +
> +	/* Generate packet burst for testing */
> +
> +	for (i = 0; i <
> TEST_ADAPTIVE_TRANSMIT_LOAD_BALANCING_RX_BURST_SLAVE_COUNT; i++) {
> +		if (generate_test_burst(&pkt_burst[i][0], burst_size, 0, 1, 0, 0, 0)
> !=
> +				burst_size)
> +			return -1;
> +
> +		virtual_ethdev_add_mbufs_to_rx_queue(
> +				test_params->slave_port_ids[i], &pkt_burst[i][0],
> burst_size);
> +	}
> +
> +	if (rte_eth_rx_burst(test_params->bonded_port_id, 0, rx_pkt_burst,
> +			MAX_PKT_BURST) != burst_size) {
> +		printf("rte_eth_rx_burst\n");
> +		return -1;
> +
> +	}
> +
> +	/* Verify bonded device rx count */
> +	rte_eth_stats_get(test_params->bonded_port_id, &port_stats);
> +	TEST_ASSERT_EQUAL(port_stats.ipackets, (uint64_t)burst_size,
> +			"(%d) port_stats.ipackets not as expected\n",
> +			test_params->bonded_port_id);
> +
> +	/* free mbufs */
> +
> +	for (i = 0; i <
> TEST_ADAPTIVE_TRANSMIT_LOAD_BALANCING_RX_BURST_SLAVE_COUNT; i++) {
> +		for (j = 0; j < MAX_PKT_BURST; j++) {
> +			if (pkt_burst[i][j] != NULL) {
> +				rte_pktmbuf_free(pkt_burst[i][j]);
> +				pkt_burst[i][j] = NULL;
> +			}
> +		}
> +	}
> +
> +
> +	/* Clean up and remove slaves from bonded device */
> +	return remove_slaves_and_stop_bonded_device();
> +}
> +
> 
>  static struct unit_test_suite link_bonding_test_suite  = {
>  	.suite_name = "Link Bonding Unit Test Suite",
> @@ -3898,6 +4392,11 @@ static struct unit_test_suite link_bonding_test_suite
> = {
>  		TEST_CASE(test_balance_verify_promiscuous_enable_disable),
>  		TEST_CASE(test_balance_verify_mac_assignment),
> 
> 	TEST_CASE(test_balance_verify_slave_link_status_change_behaviour),
> +		TEST_CASE(test_tlb_tx_burst),
> +		TEST_CASE(test_tlb_rx_burst),
> +		TEST_CASE(test_tlb_verify_mac_assignment),
> +		TEST_CASE(test_tlb_verify_promiscuous_enable_disable),
> +		TEST_CASE(test_tlb_verify_slave_link_status_change_failover),
>  		TEST_CASE(test_broadcast_tx_burst),
>  		TEST_CASE(test_broadcast_tx_burst_slave_tx_fail),
>  		TEST_CASE(test_broadcast_rx_burst),
> diff --git a/app/test/virtual_pmd.c b/app/test/virtual_pmd.c
> index fffaa35..331bec3 100644
> --- a/app/test/virtual_pmd.c
> +++ b/app/test/virtual_pmd.c
> @@ -359,16 +359,18 @@ virtual_ethdev_tx_burst_success(void *queue, struct
> rte_mbuf **bufs,
> 
>  	struct rte_eth_dev *vrtl_eth_dev;
>  	struct virtual_ethdev_private *dev_private;
> -
> +	uint64_t obytes = 0;
>  	int i;
> 
> +	for (i = 0; i < nb_pkts; i++)
> +		obytes += rte_pktmbuf_pkt_len(bufs[i]);
>  	vrtl_eth_dev = &rte_eth_devices[tx_q->port_id];
>  	dev_private = vrtl_eth_dev->data->dev_private;
> 
>  	if (vrtl_eth_dev->data->dev_link.link_status) {
>  		/* increment opacket count */
>  		dev_private->eth_stats.opackets += nb_pkts;
> -
> +		dev_private->eth_stats.obytes += obytes;
>  		/* free packets in burst */
>  		for (i = 0; i < nb_pkts; i++) {
>  			rte_pktmbuf_free(bufs[i]);
> diff --git a/app/test/virtual_pmd.h b/app/test/virtual_pmd.h
> index 2462853..4118e3e 100644
> --- a/app/test/virtual_pmd.h
> +++ b/app/test/virtual_pmd.h
> @@ -94,6 +94,13 @@ void
>  virtual_ethdev_tx_burst_fn_set_tx_pkt_fail_count(uint8_t port_id,
>  		uint8_t packet_fail_count);
> 
> +/* if a value greater than zero is set for packet_fail_count then virtual
> + * device tx burst function will fail that many packet from burst or all
> + * packets if packet_fail_count is greater than the number of packets in the
> + * burst */
> +void virtual_ethdev_tx_burst_fn_set_tx_pkt_fail_count(uint8_t port_id,
> +		uint8_t packet_fail_count);
> +
>  #ifdef __cplusplus
>  }
>  #endif
> diff --git a/lib/librte_pmd_bond/rte_eth_bond.h
> b/lib/librte_pmd_bond/rte_eth_bond.h
> index 6811c7b..682e5c7 100644
> --- a/lib/librte_pmd_bond/rte_eth_bond.h
> +++ b/lib/librte_pmd_bond/rte_eth_bond.h
> @@ -75,6 +75,29 @@ extern "C" {
>  /**< Broadcast (Mode 3).
>   * In this mode all transmitted packets will be transmitted on all available
>   * active slaves of the bonded. */
> +#define BONDING_MODE_ADAPTIVE_TRANSMIT_LOAD_BALANCING	(5)
> +/**< Broadcast (Mode 5)
> + * Adaptive transmit load balancing: channel bonding that
> + * does not require any special switch support.  The
> + * outgoing traffic is distributed according to the
> + * current load (computed relative to the speed) on each
> + * slave.  Incoming traffic is received by the current
> + * slave.  If the receiving slave fails, another slave
> + * takes over the MAC address of the failed receiving
> + * slave.*/
> +#define BONDING_MODE_ADAPTIVE_LOAD_BALANCING
> 	(6)
> +/**
> + * Adaptive load balancing: includes balance-tlb plus
> + * receive load balancing (rlb) for IPV4 traffic, and
> + * does not require any special switch support.  The
> + * receive load balancing is achieved by ARP negotiation.
> + * The bonding driver intercepts the ARP Replies sent by
> + * the local system on their way out and overwrites the
> + * source hardware address with the unique hardware
> + * address of one of the slaves in the bond such that
> + * different peers use different hardware addresses for
> + * the server. */
> +
> 
>  /* Balance Mode Transmit Policies */
>  #define BALANCE_XMIT_POLICY_LAYER2		(0)
> diff --git a/lib/librte_pmd_bond/rte_eth_bond_args.c
> b/lib/librte_pmd_bond/rte_eth_bond_args.c
> index bbbc69b..7464af5 100644
> --- a/lib/librte_pmd_bond/rte_eth_bond_args.c
> +++ b/lib/librte_pmd_bond/rte_eth_bond_args.c
> @@ -171,6 +171,7 @@ bond_ethdev_parse_slave_mode_kvarg(const char *key
> __rte_unused,
>  	case BONDING_MODE_ACTIVE_BACKUP:
>  	case BONDING_MODE_BALANCE:
>  	case BONDING_MODE_BROADCAST:
> +	case BONDING_MODE_ADAPTIVE_TRANSMIT_LOAD_BALANCING:
>  		return 0;
>  	default:
>  		RTE_BOND_LOG(ERR, "Invalid slave mode value (%s) specified",
> value);
> diff --git a/lib/librte_pmd_bond/rte_eth_bond_pmd.c
> b/lib/librte_pmd_bond/rte_eth_bond_pmd.c
> index 6d0fb1b..db6a934 100644
> --- a/lib/librte_pmd_bond/rte_eth_bond_pmd.c
> +++ b/lib/librte_pmd_bond/rte_eth_bond_pmd.c
> @@ -30,7 +30,7 @@
>   *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
> USE
>   *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>   */
> -
> +#include <stdlib.h>
>  #include <rte_mbuf.h>
>  #include <rte_malloc.h>
>  #include <rte_ethdev.h>
> @@ -41,10 +41,13 @@
>  #include <rte_kvargs.h>
>  #include <rte_dev.h>
>  #include <rte_alarm.h>
> +#include <rte_cycles.h>
> 
>  #include "rte_eth_bond.h"
>  #include "rte_eth_bond_private.h"
> 
> +#define REORDER_PERIOD_MS 10
> +
>  static uint16_t
>  bond_ethdev_rx_burst(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
>  {
> @@ -287,6 +290,141 @@ xmit_slave_hash(const struct rte_mbuf *buf, uint8_t
> slave_count, uint8_t policy)
>  	return hash % slave_count;
>  }
> 
> +struct bwg_slave {
> +	uint64_t bwg_left_int;
> +	uint64_t bwg_left_remainder;
> +	uint8_t slave;
> +};
> +
> +static int
> +bandwidth_cmp(const void *a, const void *b)
> +{
> +	const struct bwg_slave *bwg_a = a;
> +	const struct bwg_slave *bwg_b = b;
> +	int64_t diff = (int64_t)bwg_b->bwg_left_int - (int64_t)bwg_a-
> >bwg_left_int;
> +	int64_t diff2 = (int64_t)bwg_b->bwg_left_remainder -
> +			(int64_t)bwg_a->bwg_left_remainder;
> +	if (diff > 0)
> +		return 1;
> +	else if (diff < 0)
> +		return -1;
> +	else if (diff2 > 0)
> +		return 1;
> +	else if (diff2 < 0)
> +		return -1;
> +	else
> +		return 0;
> +}
> +
> +static void
> +bandwidth_left(int port_id, uint64_t load, uint8_t update_idx, struct bwg_slave
> *bwg_slave)
> +{
> +	struct rte_eth_link link_status;
> +
> +	rte_eth_link_get(port_id, &link_status);
> +	uint64_t link_bwg = link_status.link_speed * 1000000ULL / 8;
> +	if (link_bwg == 0)
> +		return;
> +	link_bwg = (link_bwg * (update_idx+1) * REORDER_PERIOD_MS);
> +	bwg_slave->bwg_left_int = (link_bwg - 1000*load) / link_bwg;
> +	bwg_slave->bwg_left_remainder = (link_bwg - 1000*load) % link_bwg;
> +}
> +
> +static void
> +bond_ethdev_update_tlb_slave_cb(void *arg)
> +{
> +	struct bond_dev_private *internals = arg;
> +	struct rte_eth_stats slave_stats;
> +	struct bwg_slave bwg_array[RTE_MAX_ETHPORTS];
> +	uint8_t slave_count;
> +	uint64_t tx_bytes;
> +	uint8_t update_stats = 0;
> +	int8_t i;
> +
> +	internals->slave_update_idx++;
> +
> +
> +	if (internals->slave_update_idx >= REORDER_PERIOD_MS)
> +		update_stats = 1;
> +
> +	for (i = 0; i < internals->active_slave_count; i++) {
> +		rte_eth_stats_get(internals->active_slaves[i], &slave_stats);
> +		tx_bytes = slave_stats.obytes -
> +				internals->slaves[i].last_obytes;
> +		bandwidth_left(internals->active_slaves[i], tx_bytes,
> +				internals->slave_update_idx, &bwg_array[i]);
> +		bwg_array[i].slave = internals->active_slaves[i];
> +
> +		if (update_stats)
> +			internals->slaves[i].last_obytes = slave_stats.obytes;
> +	}
> +
> +	if (update_stats == 1)
> +		internals->slave_update_idx = 0;
> +
> +	slave_count = i;
> +	qsort(bwg_array, slave_count, sizeof(bwg_array[0]), bandwidth_cmp);
> +	for (i = 0; i < slave_count; i++)
> +		internals->active_slaves[i] = bwg_array[i].slave;
> +
> +	rte_eal_alarm_set(REORDER_PERIOD_MS * 1000,
> bond_ethdev_update_tlb_slave_cb,
> +			(struct bond_dev_private *)internals);
> +}
> +
> +static uint16_t
> +bond_ethdev_tx_burst_tlb(void *queue, struct rte_mbuf **bufs, uint16_t
> nb_pkts)
> +{
> +	struct bond_tx_queue *bd_tx_q = (struct bond_tx_queue *)queue;
> +	struct bond_dev_private *internals = bd_tx_q->dev_private;
> +
> +	struct rte_eth_dev *primary_port = &rte_eth_devices[internals-
> >primary_port];
> +	uint16_t num_tx_total = 0;
> +	uint8_t i, j;
> +
> +	uint8_t num_of_slaves = internals->active_slave_count;
> +	uint8_t slaves[RTE_MAX_ETHPORTS];
> +
> +	struct ether_hdr *ether_hdr;
> +	struct ether_addr primary_slave_addr;
> +	struct ether_addr active_slave_addr;
> +
> +	if (num_of_slaves < 1)
> +		return num_tx_total;
> +
> +	memcpy(slaves, internals->active_slaves,
> +				sizeof(internals->active_slaves[0]) *
> num_of_slaves);
> +
> +
> +	ether_addr_copy(primary_port->data->mac_addrs,
> &primary_slave_addr);
> +
> +	if (nb_pkts > 3) {
> +		for (i = 0; i < 3; i++)
> +			rte_prefetch0(rte_pktmbuf_mtod(bufs[i], void*));
> +	}
> +
> +	for (i = 0; i < num_of_slaves; i++) {
> +		ether_addr_copy(&internals-
> >slaves[slaves[i]].persisted_mac_addr,
> +				&active_slave_addr);
> +
> +		for (j = num_tx_total; j < nb_pkts; j++) {
> +			if (j + 3 < nb_pkts)
> +				rte_prefetch0(rte_pktmbuf_mtod(bufs[j+3],
> void*));
> +
> +			ether_hdr = rte_pktmbuf_mtod(bufs[j], struct ether_hdr
> *);
> +			if (is_same_ether_addr(&ether_hdr->s_addr,
> &primary_slave_addr))
> +				ether_addr_copy(&active_slave_addr,
> &ether_hdr->s_addr);
> +		}
> +
> +		num_tx_total += rte_eth_tx_burst(slaves[i], bd_tx_q->queue_id,
> +				bufs + num_tx_total, nb_pkts - num_tx_total);
> +
> +		if (num_tx_total == nb_pkts)
> +			break;
> +	}
> +
> +	return num_tx_total;
> +}
> +
>  static uint16_t
>  bond_ethdev_tx_burst_balance(void *queue, struct rte_mbuf **bufs,
>  		uint16_t nb_pkts)
> @@ -495,6 +633,7 @@ mac_address_slaves_update(struct rte_eth_dev
> *bonded_eth_dev)
>  		}
>  		break;
>  	case BONDING_MODE_ACTIVE_BACKUP:
> +	case BONDING_MODE_ADAPTIVE_TRANSMIT_LOAD_BALANCING:
>  	default:
>  		for (i = 0; i < internals->slave_count; i++) {
>  			if (internals->slaves[i].port_id ==
> @@ -544,6 +683,10 @@ bond_ethdev_mode_set(struct rte_eth_dev *eth_dev,
> int mode)
>  		eth_dev->tx_pkt_burst = bond_ethdev_tx_burst_broadcast;
>  		eth_dev->rx_pkt_burst = bond_ethdev_rx_burst;
>  		break;
> +	case BONDING_MODE_ADAPTIVE_TRANSMIT_LOAD_BALANCING:
> +		eth_dev->tx_pkt_burst = bond_ethdev_tx_burst_tlb;
> +		eth_dev->rx_pkt_burst = bond_ethdev_rx_burst_active_backup;
> +		break;
>  	default:
>  		return -1;
>  	}
> @@ -757,6 +900,9 @@ bond_ethdev_start(struct rte_eth_dev *eth_dev)
>  				bond_ethdev_slave_link_status_change_monitor,
>  				(void *)eth_dev);
> 
> +	if (internals->mode ==
> BONDING_MODE_ADAPTIVE_TRANSMIT_LOAD_BALANCING) {
> +		bond_ethdev_update_tlb_slave_cb(internals);
> +	}
>  	return 0;
>  }
> 
> @@ -765,6 +911,9 @@ bond_ethdev_stop(struct rte_eth_dev *eth_dev)
>  {
>  	struct bond_dev_private *internals = eth_dev->data->dev_private;
> 
> +	if (internals->mode ==
> BONDING_MODE_ADAPTIVE_TRANSMIT_LOAD_BALANCING) {
> +		rte_eal_alarm_cancel(bond_ethdev_update_tlb_slave_cb,
> internals);
> +    }
>  	internals->active_slave_count = 0;
>  	internals->link_status_polling_enabled = 0;
> 
> @@ -775,6 +924,12 @@ bond_ethdev_stop(struct rte_eth_dev *eth_dev)
>  static void
>  bond_ethdev_close(struct rte_eth_dev *dev __rte_unused)
>  {
> +	struct bond_dev_private *internals = dev->data->dev_private;
> +
> +	if (internals->mode ==
> BONDING_MODE_ADAPTIVE_TRANSMIT_LOAD_BALANCING) {
> +		rte_eal_alarm_cancel(bond_ethdev_update_tlb_slave_cb,
> internals);
> +	}
> +	internals->active_slave_count = 0;
>  }
> 
>  static int
> @@ -884,7 +1039,7 @@ bond_ethdev_slave_link_status_change_monitor(void
> *cb_arg)
> 
>  	/* If device is currently being configured then don't check slaves link
>  	 * status, wait until next period */
> -	if (rte_spinlock_trylock(&internals->lock)){
> +	if (rte_spinlock_trylock(&internals->lock)) {
>  		for (i = 0; i < internals->slave_count; i++) {
>  			if (internals->slaves[i].link_status_polling_enabled) {
>  				slave_ethdev = &rte_eth_devices[internals-
> >slaves[i].port_id];
> @@ -1004,6 +1159,7 @@ bond_ethdev_promiscuous_enable(struct
> rte_eth_dev *eth_dev)
>  		break;
>  	/* Promiscuous mode is propagated only to primary slave */
>  	case BONDING_MODE_ACTIVE_BACKUP:
> +	case BONDING_MODE_ADAPTIVE_TRANSMIT_LOAD_BALANCING:
>  	default:
>  		rte_eth_promiscuous_enable(internals->current_primary_port);
> 
> @@ -1028,6 +1184,7 @@ bond_ethdev_promiscuous_disable(struct
> rte_eth_dev *dev)
>  		break;
>  	/* Promiscuous mode is propagated only to primary slave */
>  	case BONDING_MODE_ACTIVE_BACKUP:
> +	case BONDING_MODE_ADAPTIVE_TRANSMIT_LOAD_BALANCING:
>  	default:
>  		rte_eth_promiscuous_disable(internals->current_primary_port);
>  	}
> diff --git a/lib/librte_pmd_bond/rte_eth_bond_private.h
> b/lib/librte_pmd_bond/rte_eth_bond_private.h
> index 6db5144..f7186a8 100644
> --- a/lib/librte_pmd_bond/rte_eth_bond_private.h
> +++ b/lib/librte_pmd_bond/rte_eth_bond_private.h
> @@ -89,7 +89,6 @@ struct bond_tx_queue {
>  	/**< Copy of TX configuration structure for queue */
>  };
> 
> -
>  /** Bonded slave devices structure */
>  struct bond_ethdev_slave_ports {
>  	uint8_t slaves[RTE_MAX_ETHPORTS];	/**< Slave port id array */
> @@ -102,6 +101,7 @@ struct bond_slave_details {
>  	uint8_t link_status_polling_enabled;
>  	uint8_t link_status_wait_to_complete;
>  	uint8_t last_link_status;
> +	uint64_t last_obytes;
> 
>  	/**< Port Id of slave eth_dev */
>  	struct ether_addr persisted_mac_addr;
> @@ -143,6 +143,7 @@ struct bond_dev_private {
>  	uint8_t slave_count;			/**< Number of bonded slaves */
>  	struct bond_slave_details slaves[RTE_MAX_ETHPORTS];
>  	/**< Arary of bonded slaves details */
> +	uint8_t slave_update_idx;
>  };
> 
>  extern struct eth_dev_ops default_dev_ops;
> --
> 1.7.9.5

Acked-by: Declan Doherty <declan.doherty@intel.com>