[dpdk-dev] [RFC] app/testpmd: add profiling for Rx/Tx burst routines

Iremonger, Bernard bernard.iremonger at intel.com
Fri Jun 7 18:07:42 CEST 2019


Hi Viacheslav,


> -----Original Message-----
> From: dev [mailto:dev-bounces at dpdk.org] On Behalf Of Viacheslav Ovsiienko
> Sent: Monday, May 27, 2019 6:47 AM
> To: dev at dpdk.org
> Cc: Yigit, Ferruh <ferruh.yigit at intel.com>
> Subject: [dpdk-dev] [RFC] app/testpmd: add profiling for Rx/Tx burst routines
> 
> There is the testpmd configuration option called
> RTE_TEST_PMD_RECORD_CORE_CYCLES, if this one is turned on the testpmd
> application measures the CPU clocks spent within forwarding loop. This time is
> the sum of execution times of rte_eth_rx_burst(), rte_eth_tx_burst(),
> rte_delay_us(),
>  rte_pktmbuf_free() and so on, depending on fwd mode set.
> 
> While debugging and performance optimization of datapath burst routines tt
> would be useful to see the pure execution times of these ones. It is proposed to
> add separated profiling
> options:
> 
> CONFIG_RTE_TEST_PMD_RECORD_CORE_TX_CYCLES
>     enables gathering profiling data for transmit datapath,
>     ticks spent within rte_eth_tx_burst()
> 
> CONFIG_RTE_TEST_PMD_RECORD_CORE_RX_CYCLES
>     enables gathering profiling data for transmit datapath,
>     ticks spent within rte_eth_rx_burst()
> 
> Signed-off-by: Viacheslav Ovsiienko <viacheslavo at mellanox.com>
> ---
>  app/test-pmd/csumonly.c   | 25 ++++++++++++-------------
>  app/test-pmd/flowgen.c    | 25 +++++++++++++------------
>  app/test-pmd/icmpecho.c   | 26 +++++++++++++-------------
>  app/test-pmd/iofwd.c      | 24 ++++++++++++------------
>  app/test-pmd/macfwd.c     | 24 +++++++++++++-----------
>  app/test-pmd/macswap.c    | 26 ++++++++++++++------------
>  app/test-pmd/rxonly.c     | 17 ++++++-----------
>  app/test-pmd/softnicfwd.c | 24 ++++++++++++------------
>  app/test-pmd/testpmd.c    | 32 ++++++++++++++++++++++++++++++++
>  app/test-pmd/testpmd.h    | 40
> ++++++++++++++++++++++++++++++++++++++++
>  app/test-pmd/txonly.c     | 23 +++++++++++------------
>  config/common_base        |  2 ++
>  12 files changed, 180 insertions(+), 108 deletions(-)
> 
> diff --git a/app/test-pmd/csumonly.c b/app/test-pmd/csumonly.c index
> f4f2a7b..251e179 100644
> --- a/app/test-pmd/csumonly.c
> +++ b/app/test-pmd/csumonly.c
> @@ -710,19 +710,19 @@ struct simple_gre_hdr {
>  	uint16_t nb_segments = 0;
>  	int ret;
> 
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	uint64_t start_tsc;
> -	uint64_t end_tsc;
> -	uint64_t core_cycles;
> +#if defined(RTE_TEST_PMD_RECORD_CORE_TX_CYCLES)
> +	uint64_t start_tx_tsc;

Should the RTE_TEST_PMD_RECORD_CORE_CYCLES macro be checked here too?

>  #endif
> -
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	start_tsc = rte_rdtsc();
> +#if defined(RTE_TEST_PMD_RECORD_CORE_CYCLES) || \
> +	defined(RTE_TEST_PMD_RECORD_CORE_RX_CYCLES)
> +	uint64_t start_rx_tsc;
>  #endif
> 
>  	/* receive a burst of packet */
> +	TEST_PMD_CORE_CYC_RX_START(start_rx_tsc);
>  	nb_rx = rte_eth_rx_burst(fs->rx_port, fs->rx_queue, pkts_burst,
>  				 nb_pkt_per_burst);
> +	TEST_PMD_CORE_CYC_RX_ADD(fs, start_rx_tsc);
>  	if (unlikely(nb_rx == 0))
>  		return;
>  #ifdef RTE_TEST_PMD_RECORD_BURST_STATS
> @@ -982,8 +982,10 @@ struct simple_gre_hdr {
>  		printf("Preparing packet burst to transmit failed: %s\n",
>  				rte_strerror(rte_errno));
> 
> +	TEST_PMD_CORE_CYC_TX_START(start_tx_tsc);
>  	nb_tx = rte_eth_tx_burst(fs->tx_port, fs->tx_queue, tx_pkts_burst,
>  			nb_prep);
> +	TEST_PMD_CORE_CYC_TX_ADD(fs, start_tx_tsc);
> 
>  	/*
>  	 * Retry if necessary
> @@ -992,8 +994,10 @@ struct simple_gre_hdr {
>  		retry = 0;
>  		while (nb_tx < nb_rx && retry++ < burst_tx_retry_num) {
>  			rte_delay_us(burst_tx_delay_time);
> +			TEST_PMD_CORE_CYC_TX_START(start_tx_tsc);
>  			nb_tx += rte_eth_tx_burst(fs->tx_port, fs->tx_queue,
>  					&tx_pkts_burst[nb_tx], nb_rx - nb_tx);
> +			TEST_PMD_CORE_CYC_TX_ADD(fs, start_tx_tsc);
>  		}
>  	}
>  	fs->tx_packets += nb_tx;
> @@ -1010,12 +1014,7 @@ struct simple_gre_hdr {
>  			rte_pktmbuf_free(tx_pkts_burst[nb_tx]);
>  		} while (++nb_tx < nb_rx);
>  	}
> -
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	end_tsc = rte_rdtsc();
> -	core_cycles = (end_tsc - start_tsc);
> -	fs->core_cycles = (uint64_t) (fs->core_cycles + core_cycles);
> -#endif
> +	TEST_PMD_CORE_CYC_FWD_ADD(fs, start_rx_tsc);
>  }
> 
>  struct fwd_engine csum_fwd_engine = {
> diff --git a/app/test-pmd/flowgen.c b/app/test-pmd/flowgen.c index
> 3214e3c..b128e68 100644
> --- a/app/test-pmd/flowgen.c
> +++ b/app/test-pmd/flowgen.c
> @@ -130,20 +130,21 @@
>  	uint16_t i;
>  	uint32_t retry;
>  	uint64_t tx_offloads;
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	uint64_t start_tsc;
> -	uint64_t end_tsc;
> -	uint64_t core_cycles;
> -#endif
>  	static int next_flow = 0;
> 
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	start_tsc = rte_rdtsc();
> +#if defined(RTE_TEST_PMD_RECORD_CORE_TX_CYCLES)

Should the RTE_TEST_PMD_RECORD_CORE_CYCLES macro be checked here too?

> +	uint64_t start_tx_tsc;
> +#endif
> +#if defined(RTE_TEST_PMD_RECORD_CORE_CYCLES) || \
> +	defined(RTE_TEST_PMD_RECORD_CORE_RX_CYCLES)
> +	uint64_t start_rx_tsc;
>  #endif
> 
>  	/* Receive a burst of packets and discard them. */
> +	TEST_PMD_CORE_CYC_RX_START(start_rx_tsc);
>  	nb_rx = rte_eth_rx_burst(fs->rx_port, fs->rx_queue, pkts_burst,
>  				 nb_pkt_per_burst);
> +	TEST_PMD_CORE_CYC_RX_ADD(fs, start_rx_tsc);
>  	fs->rx_packets += nb_rx;
> 
>  	for (i = 0; i < nb_rx; i++)
> @@ -212,7 +213,9 @@
>  		next_flow = (next_flow + 1) % cfg_n_flows;
>  	}
> 
> +	TEST_PMD_CORE_CYC_TX_START(start_tx_tsc);
>  	nb_tx = rte_eth_tx_burst(fs->tx_port, fs->tx_queue, pkts_burst, nb_pkt);
> +	TEST_PMD_CORE_CYC_TX_ADD(fs, start_tx_tsc);
>  	/*
>  	 * Retry if necessary
>  	 */
> @@ -220,8 +223,10 @@
>  		retry = 0;
>  		while (nb_tx < nb_rx && retry++ < burst_tx_retry_num) {
>  			rte_delay_us(burst_tx_delay_time);
> +			TEST_PMD_CORE_CYC_TX_START(start_tx_tsc);
>  			nb_tx += rte_eth_tx_burst(fs->tx_port, fs->tx_queue,
>  					&pkts_burst[nb_tx], nb_rx - nb_tx);
> +			TEST_PMD_CORE_CYC_TX_ADD(fs, start_tx_tsc);
>  		}
>  	}
>  	fs->tx_packets += nb_tx;
> @@ -239,11 +244,7 @@
>  			rte_pktmbuf_free(pkts_burst[nb_tx]);
>  		} while (++nb_tx < nb_pkt);
>  	}
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	end_tsc = rte_rdtsc();
> -	core_cycles = (end_tsc - start_tsc);
> -	fs->core_cycles = (uint64_t) (fs->core_cycles + core_cycles);
> -#endif
> +	TEST_PMD_CORE_CYC_FWD_ADD(fs, start_rx_tsc);
>  }
> 
>  struct fwd_engine flow_gen_engine = {
> diff --git a/app/test-pmd/icmpecho.c b/app/test-pmd/icmpecho.c index
> 55d266d..a539fe8 100644
> --- a/app/test-pmd/icmpecho.c
> +++ b/app/test-pmd/icmpecho.c
> @@ -293,21 +293,22 @@
>  	uint32_t cksum;
>  	uint8_t  i;
>  	int l2_len;
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	uint64_t start_tsc;
> -	uint64_t end_tsc;
> -	uint64_t core_cycles;
> -#endif
> 
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	start_tsc = rte_rdtsc();
> +#if defined(RTE_TEST_PMD_RECORD_CORE_TX_CYCLES)
> +	uint64_t start_tx_tsc;
> +#endif
> +#if defined(RTE_TEST_PMD_RECORD_CORE_CYCLES) || \
> +	defined(RTE_TEST_PMD_RECORD_CORE_RX_CYCLES)
> +	uint64_t start_rx_tsc;
>  #endif
> 
>  	/*
>  	 * First, receive a burst of packets.
>  	 */
> +	TEST_PMD_CORE_CYC_RX_START(start_rx_tsc);
>  	nb_rx = rte_eth_rx_burst(fs->rx_port, fs->rx_queue, pkts_burst,
>  				 nb_pkt_per_burst);
> +	TEST_PMD_CORE_CYC_RX_ADD(fs, start_rx_tsc);
>  	if (unlikely(nb_rx == 0))
>  		return;
> 
> @@ -487,8 +488,10 @@
> 
>  	/* Send back ICMP echo replies, if any. */
>  	if (nb_replies > 0) {
> +		TEST_PMD_CORE_CYC_TX_START(start_tx_tsc);
>  		nb_tx = rte_eth_tx_burst(fs->tx_port, fs->tx_queue, pkts_burst,
>  					 nb_replies);
> +		TEST_PMD_CORE_CYC_TX_ADD(fs, start_tx_tsc);
>  		/*
>  		 * Retry if necessary
>  		 */
> @@ -497,10 +500,12 @@
>  			while (nb_tx < nb_replies &&
>  					retry++ < burst_tx_retry_num) {
>  				rte_delay_us(burst_tx_delay_time);
> +
> 	TEST_PMD_CORE_CYC_TX_START(start_tx_tsc);
>  				nb_tx += rte_eth_tx_burst(fs->tx_port,
>  						fs->tx_queue,
>  						&pkts_burst[nb_tx],
>  						nb_replies - nb_tx);
> +				TEST_PMD_CORE_CYC_TX_ADD(fs,
> start_tx_tsc);
>  			}
>  		}
>  		fs->tx_packets += nb_tx;
> @@ -514,12 +519,7 @@
>  			} while (++nb_tx < nb_replies);
>  		}
>  	}
> -
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	end_tsc = rte_rdtsc();
> -	core_cycles = (end_tsc - start_tsc);
> -	fs->core_cycles = (uint64_t) (fs->core_cycles + core_cycles);
> -#endif
> +	TEST_PMD_CORE_CYC_FWD_ADD(fs, start_rx_tsc);
>  }
> 
>  struct fwd_engine icmp_echo_engine = {
> diff --git a/app/test-pmd/iofwd.c b/app/test-pmd/iofwd.c index
> 9dce76e..dc66a88 100644
> --- a/app/test-pmd/iofwd.c
> +++ b/app/test-pmd/iofwd.c
> @@ -51,21 +51,21 @@
>  	uint16_t nb_tx;
>  	uint32_t retry;
> 
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	uint64_t start_tsc;
> -	uint64_t end_tsc;
> -	uint64_t core_cycles;
> +#if defined(RTE_TEST_PMD_RECORD_CORE_TX_CYCLES)

Should the RTE_TEST_PMD_RECORD_CORE_CYCLES macro be checked here too?

> +	uint64_t start_tx_tsc;
>  #endif
> -
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	start_tsc = rte_rdtsc();
> +#if defined(RTE_TEST_PMD_RECORD_CORE_CYCLES) || \
> +	defined(RTE_TEST_PMD_RECORD_CORE_RX_CYCLES)
> +	uint64_t start_rx_tsc;
>  #endif
> 
>  	/*
>  	 * Receive a burst of packets and forward them.
>  	 */
> +	TEST_PMD_CORE_CYC_RX_START(start_rx_tsc);
>  	nb_rx = rte_eth_rx_burst(fs->rx_port, fs->rx_queue,
>  			pkts_burst, nb_pkt_per_burst);
> +	TEST_PMD_CORE_CYC_RX_ADD(fs, start_rx_tsc);
>  	if (unlikely(nb_rx == 0))
>  		return;
>  	fs->rx_packets += nb_rx;
> @@ -73,8 +73,10 @@
>  #ifdef RTE_TEST_PMD_RECORD_BURST_STATS
>  	fs->rx_burst_stats.pkt_burst_spread[nb_rx]++;
>  #endif
> +	TEST_PMD_CORE_CYC_TX_START(start_tx_tsc);
>  	nb_tx = rte_eth_tx_burst(fs->tx_port, fs->tx_queue,
>  			pkts_burst, nb_rx);
> +	TEST_PMD_CORE_CYC_TX_ADD(fs, start_tx_tsc);
>  	/*
>  	 * Retry if necessary
>  	 */
> @@ -82,8 +84,10 @@
>  		retry = 0;
>  		while (nb_tx < nb_rx && retry++ < burst_tx_retry_num) {
>  			rte_delay_us(burst_tx_delay_time);
> +			TEST_PMD_CORE_CYC_TX_START(start_tx_tsc);
>  			nb_tx += rte_eth_tx_burst(fs->tx_port, fs->tx_queue,
>  					&pkts_burst[nb_tx], nb_rx - nb_tx);
> +			TEST_PMD_CORE_CYC_TX_ADD(fs, start_tx_tsc);
>  		}
>  	}
>  	fs->tx_packets += nb_tx;
> @@ -96,11 +100,7 @@
>  			rte_pktmbuf_free(pkts_burst[nb_tx]);
>  		} while (++nb_tx < nb_rx);
>  	}
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	end_tsc = rte_rdtsc();
> -	core_cycles = (end_tsc - start_tsc);
> -	fs->core_cycles = (uint64_t) (fs->core_cycles + core_cycles);
> -#endif
> +	TEST_PMD_CORE_CYC_FWD_ADD(fs, start_rx_tsc);
>  }
> 
>  struct fwd_engine io_fwd_engine = {
> diff --git a/app/test-pmd/macfwd.c b/app/test-pmd/macfwd.c index
> 7cac757..2fd38ea 100644
> --- a/app/test-pmd/macfwd.c
> +++ b/app/test-pmd/macfwd.c
> @@ -56,21 +56,23 @@
>  	uint16_t i;
>  	uint64_t ol_flags = 0;
>  	uint64_t tx_offloads;
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	uint64_t start_tsc;
> -	uint64_t end_tsc;
> -	uint64_t core_cycles;
> +
> +#if defined(RTE_TEST_PMD_RECORD_CORE_TX_CYCLES)

Should the RTE_TEST_PMD_RECORD_CORE_CYCLES macro be checked here too?

> +	uint64_t start_tx_tsc;
>  #endif
> +#if defined(RTE_TEST_PMD_RECORD_CORE_CYCLES) || \
> +	defined(RTE_TEST_PMD_RECORD_CORE_RX_CYCLES)
> +	uint64_t start_rx_tsc;
> 
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	start_tsc = rte_rdtsc();
>  #endif
> 
>  	/*
>  	 * Receive a burst of packets and forward them.
>  	 */
> +	TEST_PMD_CORE_CYC_RX_START(start_rx_tsc);
>  	nb_rx = rte_eth_rx_burst(fs->rx_port, fs->rx_queue, pkts_burst,
>  				 nb_pkt_per_burst);
> +	TEST_PMD_CORE_CYC_RX_ADD(fs, start_rx_tsc);
>  	if (unlikely(nb_rx == 0))
>  		return;
> 
> @@ -103,7 +105,9 @@
>  		mb->vlan_tci = txp->tx_vlan_id;
>  		mb->vlan_tci_outer = txp->tx_vlan_id_outer;
>  	}
> +	TEST_PMD_CORE_CYC_TX_START(start_tx_tsc);
>  	nb_tx = rte_eth_tx_burst(fs->tx_port, fs->tx_queue, pkts_burst, nb_rx);
> +	TEST_PMD_CORE_CYC_TX_ADD(fs, start_tx_tsc);
>  	/*
>  	 * Retry if necessary
>  	 */
> @@ -111,8 +115,10 @@
>  		retry = 0;
>  		while (nb_tx < nb_rx && retry++ < burst_tx_retry_num) {
>  			rte_delay_us(burst_tx_delay_time);
> +			TEST_PMD_CORE_CYC_TX_START(start_tx_tsc);
>  			nb_tx += rte_eth_tx_burst(fs->tx_port, fs->tx_queue,
>  					&pkts_burst[nb_tx], nb_rx - nb_tx);
> +			TEST_PMD_CORE_CYC_TX_ADD(fs, start_tx_tsc);
>  		}
>  	}
> 
> @@ -126,11 +132,7 @@
>  			rte_pktmbuf_free(pkts_burst[nb_tx]);
>  		} while (++nb_tx < nb_rx);
>  	}
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	end_tsc = rte_rdtsc();
> -	core_cycles = (end_tsc - start_tsc);
> -	fs->core_cycles = (uint64_t) (fs->core_cycles + core_cycles);
> -#endif
> +	TEST_PMD_CORE_CYC_FWD_ADD(fs, start_rx_tsc);
>  }
> 
>  struct fwd_engine mac_fwd_engine = {
> diff --git a/app/test-pmd/macswap.c b/app/test-pmd/macswap.c index
> 71af916..b22acdb 100644
> --- a/app/test-pmd/macswap.c
> +++ b/app/test-pmd/macswap.c
> @@ -86,21 +86,22 @@
>  	uint16_t nb_rx;
>  	uint16_t nb_tx;
>  	uint32_t retry;
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	uint64_t start_tsc;
> -	uint64_t end_tsc;
> -	uint64_t core_cycles;
> -#endif
> 
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	start_tsc = rte_rdtsc();
> +#if defined(RTE_TEST_PMD_RECORD_CORE_TX_CYCLES)

Should the RTE_TEST_PMD_RECORD_CORE_CYCLES macro be checked here too?

> +	uint64_t start_tx_tsc;
> +#endif
> +#if defined(RTE_TEST_PMD_RECORD_CORE_CYCLES) || \
> +	defined(RTE_TEST_PMD_RECORD_CORE_RX_CYCLES)
> +	uint64_t start_rx_tsc;
>  #endif
> 
>  	/*
>  	 * Receive a burst of packets and forward them.
>  	 */
> +	TEST_PMD_CORE_CYC_RX_START(start_rx_tsc);
>  	nb_rx = rte_eth_rx_burst(fs->rx_port, fs->rx_queue, pkts_burst,
>  				 nb_pkt_per_burst);
> +	TEST_PMD_CORE_CYC_RX_ADD(fs, start_rx_tsc);
>  	if (unlikely(nb_rx == 0))
>  		return;
> 
> @@ -112,7 +113,10 @@
> 
>  	do_macswap(pkts_burst, nb_rx, txp);
> 
> +	TEST_PMD_CORE_CYC_TX_START(start_tx_tsc);
>  	nb_tx = rte_eth_tx_burst(fs->tx_port, fs->tx_queue, pkts_burst, nb_rx);
> +	TEST_PMD_CORE_CYC_TX_ADD(fs, start_tx_tsc);
> +
>  	/*
>  	 * Retry if necessary
>  	 */
> @@ -120,8 +124,10 @@
>  		retry = 0;
>  		while (nb_tx < nb_rx && retry++ < burst_tx_retry_num) {
>  			rte_delay_us(burst_tx_delay_time);
> +			TEST_PMD_CORE_CYC_TX_START(start_tx_tsc);
>  			nb_tx += rte_eth_tx_burst(fs->tx_port, fs->tx_queue,
>  					&pkts_burst[nb_tx], nb_rx - nb_tx);
> +			TEST_PMD_CORE_CYC_TX_ADD(fs, start_tx_tsc);
>  		}
>  	}
>  	fs->tx_packets += nb_tx;
> @@ -134,11 +140,7 @@
>  			rte_pktmbuf_free(pkts_burst[nb_tx]);
>  		} while (++nb_tx < nb_rx);
>  	}
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	end_tsc = rte_rdtsc();
> -	core_cycles = (end_tsc - start_tsc);
> -	fs->core_cycles = (uint64_t) (fs->core_cycles + core_cycles);
> -#endif
> +	TEST_PMD_CORE_CYC_FWD_ADD(fs, start_rx_tsc);
>  }
> 
>  struct fwd_engine mac_swap_engine = {
> diff --git a/app/test-pmd/rxonly.c b/app/test-pmd/rxonly.c index
> 5c65fc4..d1da357 100644
> --- a/app/test-pmd/rxonly.c
> +++ b/app/test-pmd/rxonly.c
> @@ -50,19 +50,18 @@
>  	uint16_t nb_rx;
>  	uint16_t i;
> 
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	uint64_t start_tsc;
> -	uint64_t end_tsc;
> -	uint64_t core_cycles;
> -
> -	start_tsc = rte_rdtsc();
> +#if defined(RTE_TEST_PMD_RECORD_CORE_CYCLES) || \
> +	defined(RTE_TEST_PMD_RECORD_CORE_RX_CYCLES)
> +	uint64_t start_rx_tsc;
>  #endif
> 
>  	/*
>  	 * Receive a burst of packets.
>  	 */
> +	TEST_PMD_CORE_CYC_RX_START(start_rx_tsc);
>  	nb_rx = rte_eth_rx_burst(fs->rx_port, fs->rx_queue, pkts_burst,
>  				 nb_pkt_per_burst);
> +	TEST_PMD_CORE_CYC_RX_ADD(fs, start_rx_tsc);
>  	if (unlikely(nb_rx == 0))
>  		return;
> 
> @@ -73,11 +72,7 @@
>  	for (i = 0; i < nb_rx; i++)
>  		rte_pktmbuf_free(pkts_burst[i]);
> 
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	end_tsc = rte_rdtsc();
> -	core_cycles = (end_tsc - start_tsc);
> -	fs->core_cycles = (uint64_t) (fs->core_cycles + core_cycles);
> -#endif
> +	TEST_PMD_CORE_CYC_FWD_ADD(fs, start_rx_tsc);
>  }
> 
>  struct fwd_engine rx_only_engine = {
> diff --git a/app/test-pmd/softnicfwd.c b/app/test-pmd/softnicfwd.c index
> 94e6669..9b2b0e6 100644
> --- a/app/test-pmd/softnicfwd.c
> +++ b/app/test-pmd/softnicfwd.c
> @@ -87,35 +87,39 @@ struct tm_hierarchy {
>  	uint16_t nb_tx;
>  	uint32_t retry;
> 
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	uint64_t start_tsc;
> -	uint64_t end_tsc;
> -	uint64_t core_cycles;
> +#if defined(RTE_TEST_PMD_RECORD_CORE_TX_CYCLES)

Should the RTE_TEST_PMD_RECORD_CORE_CYCLES macro be checked here too?

> +	uint64_t start_tx_tsc;
>  #endif
> -
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	start_tsc = rte_rdtsc();
> +#if defined(RTE_TEST_PMD_RECORD_CORE_CYCLES) || \
> +	defined(RTE_TEST_PMD_RECORD_CORE_RX_CYCLES)
> +	uint64_t start_rx_tsc;
>  #endif
> 
>  	/*  Packets Receive */
> +	TEST_PMD_CORE_CYC_RX_START(start_rx_tsc);
>  	nb_rx = rte_eth_rx_burst(fs->rx_port, fs->rx_queue,
>  			pkts_burst, nb_pkt_per_burst);
> +	TEST_PMD_CORE_CYC_RX_ADD(fs, start_rx_tsc);
>  	fs->rx_packets += nb_rx;
> 
>  #ifdef RTE_TEST_PMD_RECORD_BURST_STATS
>  	fs->rx_burst_stats.pkt_burst_spread[nb_rx]++;
>  #endif
> 
> +	TEST_PMD_CORE_CYC_TX_START(start_tx_tsc);
>  	nb_tx = rte_eth_tx_burst(fs->tx_port, fs->tx_queue,
>  			pkts_burst, nb_rx);
> +	TEST_PMD_CORE_CYC_TX_ADD(fs, start_tx_tsc);
> 
>  	/* Retry if necessary */
>  	if (unlikely(nb_tx < nb_rx) && fs->retry_enabled) {
>  		retry = 0;
>  		while (nb_tx < nb_rx && retry++ < burst_tx_retry_num) {
>  			rte_delay_us(burst_tx_delay_time);
> +			TEST_PMD_CORE_CYC_TX_START(start_tx_tsc);
>  			nb_tx += rte_eth_tx_burst(fs->tx_port, fs->tx_queue,
>  					&pkts_burst[nb_tx], nb_rx - nb_tx);
> +			TEST_PMD_CORE_CYC_TX_ADD(fs, start_tx_tsc);
>  		}
>  	}
>  	fs->tx_packets += nb_tx;
> @@ -130,11 +134,7 @@ struct tm_hierarchy {
>  			rte_pktmbuf_free(pkts_burst[nb_tx]);
>  		} while (++nb_tx < nb_rx);
>  	}
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	end_tsc = rte_rdtsc();
> -	core_cycles = (end_tsc - start_tsc);
> -	fs->core_cycles = (uint64_t) (fs->core_cycles + core_cycles);
> -#endif
> +	TEST_PMD_CORE_CYC_FWD_ADD(fs, start_rx_tsc);
>  }
> 
>  static void
> diff --git a/app/test-pmd/testpmd.c b/app/test-pmd/testpmd.c index
> f0061d9..de8478f 100644
> --- a/app/test-pmd/testpmd.c
> +++ b/app/test-pmd/testpmd.c
> @@ -1483,6 +1483,12 @@ struct extmem_param {  #ifdef
> RTE_TEST_PMD_RECORD_CORE_CYCLES
>  	uint64_t fwd_cycles = 0;
>  #endif
> +#ifdef RTE_TEST_PMD_RECORD_CORE_RX_CYCLES
> +	uint64_t rx_cycles = 0;
> +#endif
> +#ifdef RTE_TEST_PMD_RECORD_CORE_TX_CYCLES
> +	uint64_t tx_cycles = 0;
> +#endif
>  	uint64_t total_recv = 0;
>  	uint64_t total_xmit = 0;
>  	struct rte_port *port;
> @@ -1513,6 +1519,12 @@ struct extmem_param {  #ifdef
> RTE_TEST_PMD_RECORD_CORE_CYCLES
>  		fwd_cycles += fs->core_cycles;
>  #endif
> +#ifdef RTE_TEST_PMD_RECORD_CORE_RX_CYCLES
> +		rx_cycles += fs->core_rx_cycles;
> +#endif
> +#ifdef RTE_TEST_PMD_RECORD_CORE_TX_CYCLES
> +		tx_cycles += fs->core_tx_cycles;
> +#endif
>  	}
>  	for (i = 0; i < cur_fwd_config.nb_fwd_ports; i++) {
>  		uint8_t j;
> @@ -1648,6 +1660,20 @@ struct extmem_param {
>  		       (unsigned int)(fwd_cycles / total_recv),
>  		       fwd_cycles, total_recv);
>  #endif
> +#ifdef RTE_TEST_PMD_RECORD_CORE_RX_CYCLES
> +	if (total_recv > 0)
> +		printf("\n  rx CPU cycles/packet=%u (total cycles="
> +		       "%"PRIu64" / total RX packets=%"PRIu64")\n",
> +		       (unsigned int)(rx_cycles / total_recv),
> +		       rx_cycles, total_recv);
> +#endif
> +#ifdef RTE_TEST_PMD_RECORD_CORE_TX_CYCLES
> +	if (total_xmit > 0)
> +		printf("\n  tx CPU cycles/packet=%u (total cycles="
> +		       "%"PRIu64" / total TX packets=%"PRIu64")\n",
> +		       (unsigned int)(tx_cycles / total_xmit),
> +		       tx_cycles, total_xmit);
> +#endif
>  }
> 
>  void
> @@ -1678,6 +1704,12 @@ struct extmem_param {  #ifdef
> RTE_TEST_PMD_RECORD_CORE_CYCLES
>  		fs->core_cycles = 0;
>  #endif
> +#ifdef RTE_TEST_PMD_RECORD_CORE_RX_CYCLES
> +		fs->core_rx_cycles = 0;
> +#endif
> +#ifdef RTE_TEST_PMD_RECORD_CORE_TX_CYCLES
> +		fs->core_tx_cycles = 0;
> +#endif
>  	}
>  }
> 
> diff --git a/app/test-pmd/testpmd.h b/app/test-pmd/testpmd.h index
> 1d9b7a2..4e8af8a 100644
> --- a/app/test-pmd/testpmd.h
> +++ b/app/test-pmd/testpmd.h
> @@ -130,12 +130,52 @@ struct fwd_stream {  #ifdef
> RTE_TEST_PMD_RECORD_CORE_CYCLES
>  	uint64_t     core_cycles; /**< used for RX and TX processing */
>  #endif
> +#ifdef RTE_TEST_PMD_RECORD_CORE_TX_CYCLES
> +	uint64_t     core_tx_cycles; /**< used for tx_burst processing */
> +#endif
> +#ifdef RTE_TEST_PMD_RECORD_CORE_RX_CYCLES
> +	uint64_t     core_rx_cycles; /**< used for rx_burst processing */
> +#endif
>  #ifdef RTE_TEST_PMD_RECORD_BURST_STATS
>  	struct pkt_burst_stats rx_burst_stats;
>  	struct pkt_burst_stats tx_burst_stats;  #endif  };
> 
> +#if defined(RTE_TEST_PMD_RECORD_CORE_TX_CYCLES)
> +#define TEST_PMD_CORE_CYC_TX_START(a) {a = rte_rdtsc(); } #else #define
> +TEST_PMD_CORE_CYC_TX_START(a) #endif
> +
> +#if defined(RTE_TEST_PMD_RECORD_CORE_CYCLES) || \
> +	defined(RTE_TEST_PMD_RECORD_CORE_RX_CYCLES)
> +#define TEST_PMD_CORE_CYC_RX_START(a) {a = rte_rdtsc(); } #else #define
> +TEST_PMD_CORE_CYC_RX_START(a) #endif
> +
> +#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> +#define TEST_PMD_CORE_CYC_FWD_ADD(fs, s) \ {uint64_t end_tsc =
> +rte_rdtsc(); fs->core_cycles += end_tsc - (s); } #else #define
> +TEST_PMD_CORE_CYC_FWD_ADD(fs, s) #endif
> +
> +#ifdef RTE_TEST_PMD_RECORD_CORE_TX_CYCLES
> +#define TEST_PMD_CORE_CYC_TX_ADD(fs, s) \ {uint64_t end_tsc =
> +rte_rdtsc(); fs->core_tx_cycles += end_tsc - (s); } #else #define
> +TEST_PMD_CORE_CYC_TX_ADD(fs, s) #endif
> +
> +#ifdef RTE_TEST_PMD_RECORD_CORE_RX_CYCLES
> +#define TEST_PMD_CORE_CYC_RX_ADD(fs, s) \ {uint64_t end_tsc =
> +rte_rdtsc(); fs->core_rx_cycles += end_tsc - (s); } #else #define
> +TEST_PMD_CORE_CYC_RX_ADD(fs, s) #endif
> +
>  /** Descriptor for a single flow. */
>  struct port_flow {
>  	struct port_flow *next; /**< Next flow in list. */ diff --git a/app/test-
> pmd/txonly.c b/app/test-pmd/txonly.c index fdfca14..fe3045a 100644
> --- a/app/test-pmd/txonly.c
> +++ b/app/test-pmd/txonly.c
> @@ -241,16 +241,16 @@
>  	uint32_t retry;
>  	uint64_t ol_flags = 0;
>  	uint64_t tx_offloads;
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	uint64_t start_tsc;
> -	uint64_t end_tsc;
> -	uint64_t core_cycles;
> +#if defined(RTE_TEST_PMD_RECORD_CORE_TX_CYCLES)
> +	uint64_t start_tx_tsc;
> +#endif
> +#if defined(RTE_TEST_PMD_RECORD_CORE_CYCLES)
> +	uint64_t start_rx_tsc;
>  #endif
> 
>  #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	start_tsc = rte_rdtsc();
> +	TEST_PMD_CORE_CYC_RX_START(start_rx_tsc);
>  #endif
> -
>  	mbp = current_fwd_lcore()->mbp;
>  	txp = &ports[fs->tx_port];
>  	tx_offloads = txp->dev_conf.txmode.offloads; @@ -302,7 +302,9 @@
>  	if (nb_pkt == 0)
>  		return;
> 
> +	TEST_PMD_CORE_CYC_TX_START(start_tx_tsc);
>  	nb_tx = rte_eth_tx_burst(fs->tx_port, fs->tx_queue, pkts_burst, nb_pkt);
> +	TEST_PMD_CORE_CYC_TX_ADD(fs, start_tx_tsc);
>  	/*
>  	 * Retry if necessary
>  	 */
> @@ -310,8 +312,10 @@
>  		retry = 0;
>  		while (nb_tx < nb_pkt && retry++ < burst_tx_retry_num) {
>  			rte_delay_us(burst_tx_delay_time);
> +			TEST_PMD_CORE_CYC_TX_START(start_tx_tsc);
>  			nb_tx += rte_eth_tx_burst(fs->tx_port, fs->tx_queue,
>  					&pkts_burst[nb_tx], nb_pkt - nb_tx);
> +			TEST_PMD_CORE_CYC_TX_ADD(fs, start_tx_tsc);
>  		}
>  	}
>  	fs->tx_packets += nb_tx;
> @@ -334,12 +338,7 @@
>  			rte_pktmbuf_free(pkts_burst[nb_tx]);
>  		} while (++nb_tx < nb_pkt);
>  	}
> -
> -#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
> -	end_tsc = rte_rdtsc();
> -	core_cycles = (end_tsc - start_tsc);
> -	fs->core_cycles = (uint64_t) (fs->core_cycles + core_cycles);
> -#endif
> +	TEST_PMD_CORE_CYC_FWD_ADD(fs, start_rx_tsc);
>  }
> 
>  static void
> diff --git a/config/common_base b/config/common_base index
> 6b96e0e..6e84af4 100644
> --- a/config/common_base
> +++ b/config/common_base
> @@ -998,6 +998,8 @@ CONFIG_RTE_PROC_INFO=n  #
> CONFIG_RTE_TEST_PMD=y
> CONFIG_RTE_TEST_PMD_RECORD_CORE_CYCLES=n
> +CONFIG_RTE_TEST_PMD_RECORD_CORE_RX_CYCLES=n
> +CONFIG_RTE_TEST_PMD_RECORD_CORE_TX_CYCLES=n
>  CONFIG_RTE_TEST_PMD_RECORD_BURST_STATS=n

Should the RECORD macros be documented in the run_app.rst file ?
 
>  #
> --
> 1.8.3.1

Regards,

Bernard



More information about the dev mailing list