[dpdk-dev] [PATCH v2] ADD mode 5(tlb) to link bonding pmd
Doherty, Declan
declan.doherty at intel.com
Tue Oct 7 10:20:25 CEST 2014
> -----Original Message-----
> From: dev [mailto:dev-bounces at dpdk.org] On Behalf Of Daniel Mrzyglod
> Sent: Friday, September 26, 2014 4:41 PM
> To: dev at dpdk.org
> Subject: [dpdk-dev] [PATCH v2] ADD mode 5(tlb) to link bonding pmd
>
>
> Signed-off-by: Daniel Mrzyglod <danielx.t.mrzyglod at 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(ðer_hdr->s_addr,
> &primary_slave_addr))
> + ether_addr_copy(&active_slave_addr,
> ðer_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 at intel.com>
More information about the dev
mailing list