d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

app/testpmd: add record-core-cycles runtime config

Browse Source 
Convert CONFIG_RTE_TEST_PMD_RECORD_CORE_CYCLES to a
runtime configuration.

Signed-off-by: Dharmik Thakkar <dharmik.thakkar@arm.com>
Tested-by: Phil Yang <phil.yang@arm.com>
Reviewed-by: Ruifeng Wang <ruifeng.wang@arm.com>
Reviewed-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com>
Reviewed-by: Ferruh Yigit <ferruh.yigit@intel.com>
This commit is contained in:
Dharmik Thakkar 2020-07-14 16:51:03 -05:00 committed by Ferruh Yigit
parent 5723fbed4f
commit bc700b6767
16 changed files with 144 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
app/test-pmd/5tswap.c
View File

@ -105,15 +105,9 @@ pkt_burst_5tuple_swap(struct fwd_stream *fs)
uint8_t *byte;
} h;
#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
uint64_t start_tsc;
uint64_t end_tsc;
uint64_t core_cycles;
#endif
uint64_t start_tsc = 0;
#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
start_tsc = rte_rdtsc();
#endif
get_start_cycles(&start_tsc);
/*
* Receive a burst of packets and forward them.
@ -193,11 +187,7 @@ pkt_burst_5tuple_swap(struct fwd_stream *fs)
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
get_end_cycles(fs, start_tsc);
}
struct fwd_engine five_tuple_swap_fwd_engine = {

46
app/test-pmd/cmdline.c
View File

@ -529,6 +529,9 @@ static void cmd_help_long_parsed(void *parsed_result,
" Set the option to hide the zero values"
" for xstats display.\n"
"set record-core-cycles on|off\n"
" Set the option to enable measurement of CPU cycles.\n"
"set port (port_id) vf (vf_id) rx|tx on|off\n"
" Enable/Disable a VF receive/tranmit from a port\n\n"
@ -8335,6 +8338,48 @@ cmdline_parse_inst_t cmd_set_xstats_hide_zero = {
},
};
/* *** SET OPTION TO ENABLE MEASUREMENT OF CPU CYCLES *** */
struct cmd_set_record_core_cycles_result {
cmdline_fixed_string_t keyword;
cmdline_fixed_string_t name;
cmdline_fixed_string_t on_off;
};
static void
cmd_set_record_core_cycles_parsed(void *parsed_result,
__rte_unused struct cmdline *cl,
__rte_unused void *data)
{
struct cmd_set_record_core_cycles_result *res;
uint16_t on_off = 0;
res = parsed_result;
on_off = !strcmp(res->on_off, "on") ? 1 : 0;
set_record_core_cycles(on_off);
}
cmdline_parse_token_string_t cmd_set_record_core_cycles_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_set_record_core_cycles_result,
keyword, "set");
cmdline_parse_token_string_t cmd_set_record_core_cycles_name =
TOKEN_STRING_INITIALIZER(struct cmd_set_record_core_cycles_result,
name, "record-core-cycles");
cmdline_parse_token_string_t cmd_set_record_core_cycles_on_off =
TOKEN_STRING_INITIALIZER(struct cmd_set_record_core_cycles_result,
on_off, "on#off");
cmdline_parse_inst_t cmd_set_record_core_cycles = {
.f = cmd_set_record_core_cycles_parsed,
.data = NULL,
.help_str = "set record-core-cycles on|off",
.tokens = {
(void *)&cmd_set_record_core_cycles_keyword,
(void *)&cmd_set_record_core_cycles_name,
(void *)&cmd_set_record_core_cycles_on_off,
NULL,
},
};
/* *** CONFIGURE UNICAST HASH TABLE *** */
struct cmd_set_uc_hash_table {
cmdline_fixed_string_t set;
@ -19487,6 +19532,7 @@ cmdline_parse_ctx_t main_ctx[] = {
(cmdline_parse_inst_t *)&cmd_set_fwd_eth_peer,
(cmdline_parse_inst_t *)&cmd_set_qmap,
(cmdline_parse_inst_t *)&cmd_set_xstats_hide_zero,
(cmdline_parse_inst_t *)&cmd_set_record_core_cycles,
(cmdline_parse_inst_t *)&cmd_operate_port,
(cmdline_parse_inst_t *)&cmd_operate_specific_port,
(cmdline_parse_inst_t *)&cmd_operate_attach_port,

6
app/test-pmd/config.c
View File

@ -3680,6 +3680,12 @@ set_xstats_hide_zero(uint8_t on_off)
xstats_hide_zero = on_off;
}
void
set_record_core_cycles(uint8_t on_off)
{
record_core_cycles = on_off;
}
static inline void
print_fdir_mask(struct rte_eth_fdir_masks *mask)
{

16
app/test-pmd/csumonly.c
View File

@ -789,15 +789,9 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
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;
#endif
uint64_t start_tsc = 0;
#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
start_tsc = rte_rdtsc();
#endif
get_start_cycles(&start_tsc);
/* receive a burst of packet */
nb_rx = rte_eth_rx_burst(fs->rx_port, fs->rx_queue, pkts_burst,
@ -1098,11 +1092,7 @@ tunnel_update:
} 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
get_end_cycles(fs, start_tsc);
}
struct fwd_engine csum_fwd_engine = {

17
app/test-pmd/flowgen.c
View File

@ -97,16 +97,10 @@ pkt_burst_flow_gen(struct fwd_stream *fs)
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
uint64_t start_tsc = 0;
static int next_flow = 0;
#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
start_tsc = rte_rdtsc();
#endif
get_start_cycles(&start_tsc);
/* Receive a burst of packets and discard them. */
nb_rx = rte_eth_rx_burst(fs->rx_port, fs->rx_queue, pkts_burst,
@ -207,11 +201,8 @@ pkt_burst_flow_gen(struct fwd_stream *fs)
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
get_end_cycles(fs, start_tsc);
}
struct fwd_engine flow_gen_engine = {

16
app/test-pmd/icmpecho.c
View File

@ -293,15 +293,9 @@ reply_to_icmp_echo_rqsts(struct fwd_stream *fs)
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
uint64_t start_tsc = 0;
#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
start_tsc = rte_rdtsc();
#endif
get_start_cycles(&start_tsc);
/*
* First, receive a burst of packets.
@ -520,11 +514,7 @@ reply_to_icmp_echo_rqsts(struct fwd_stream *fs)
}
}
#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
get_end_cycles(fs, start_tsc);
}
struct fwd_engine icmp_echo_engine = {

18
app/test-pmd/iofwd.c
View File

@ -50,16 +50,9 @@ pkt_burst_io_forward(struct fwd_stream *fs)
uint16_t nb_rx;
uint16_t nb_tx;
uint32_t retry;
uint64_t start_tsc = 0;
#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();
#endif
get_start_cycles(&start_tsc);
/*
* Receive a burst of packets and forward them.
@ -96,11 +89,8 @@ pkt_burst_io_forward(struct fwd_stream *fs)
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
get_end_cycles(fs, start_tsc);
}
struct fwd_engine io_fwd_engine = {

17
app/test-pmd/macfwd.c
View File

@ -56,15 +56,9 @@ pkt_burst_mac_forward(struct fwd_stream *fs)
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;
#endif
uint64_t start_tsc = 0;
#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
start_tsc = rte_rdtsc();
#endif
get_start_cycles(&start_tsc);
/*
* Receive a burst of packets and forward them.
@ -126,11 +120,8 @@ pkt_burst_mac_forward(struct fwd_stream *fs)
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
get_end_cycles(fs, start_tsc);
}
struct fwd_engine mac_fwd_engine = {

16
app/test-pmd/macswap.c
View File

@ -57,15 +57,9 @@ pkt_burst_mac_swap(struct fwd_stream *fs)
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
uint64_t start_tsc = 0;
#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
start_tsc = rte_rdtsc();
#endif
get_start_cycles(&start_tsc);
/*
* Receive a burst of packets and forward them.
@ -105,11 +99,7 @@ pkt_burst_mac_swap(struct fwd_stream *fs)
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
get_end_cycles(fs, start_tsc);
}
struct fwd_engine mac_swap_engine = {

6
app/test-pmd/parameters.c
View File

@ -70,7 +70,7 @@ usage(char* progname)
"--rxpt= | --rxht= | --rxwt= | --rxfreet= | "
"--txpt= | --txht= | --txwt= | --txfreet= | "
"--txrst= | --tx-offloads= | | --rx-offloads= | "
"--vxlan-gpe-port= ]\n",
"--vxlan-gpe-port= | --record-core-cycles]\n",
progname);
#ifdef RTE_LIBRTE_CMDLINE
printf(" --interactive: run in interactive mode.\n");
@ -216,6 +216,7 @@ usage(char* progname)
"valid only with --mp-alloc=anon\n");
printf(" --rx-mq-mode=0xX: hexadecimal bitmask of RX mq mode can be "
"enabled\n");
printf(" --record-core-cycles: enable measurement of CPU cycles.\n");
}
#ifdef RTE_LIBRTE_CMDLINE
@ -677,6 +678,7 @@ launch_args_parse(int argc, char** argv)
{ "noisy-lkup-num-reads-writes", 1, 0, 0 },
{ "no-iova-contig", 0, 0, 0 },
{ "rx-mq-mode", 1, 0, 0 },
{ "record-core-cycles", 0, 0, 0 },
{ 0, 0, 0, 0 },
};
@ -1381,6 +1383,8 @@ launch_args_parse(int argc, char** argv)
"rx-mq-mode must be >= 0 and <= %d\n",
ETH_MQ_RX_VMDQ_DCB_RSS);
}
if (!strcmp(lgopts[opt_idx].name, "record-core-cycles"))
record_core_cycles = 1;
break;
case 'h':
usage(argv[0]);

15
app/test-pmd/rxonly.c
View File

@ -49,14 +49,9 @@ pkt_burst_receive(struct fwd_stream *fs)
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
uint16_t nb_rx;
uint16_t i;
uint64_t start_tsc = 0;
#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
uint64_t start_tsc;
uint64_t end_tsc;
uint64_t core_cycles;
start_tsc = rte_rdtsc();
#endif
get_start_cycles(&start_tsc);
/*
* Receive a burst of packets.
@ -73,11 +68,7 @@ pkt_burst_receive(struct fwd_stream *fs)
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
get_end_cycles(fs, start_tsc);
}
struct fwd_engine rx_only_engine = {

44
app/test-pmd/testpmd.c
View File

@ -475,6 +475,11 @@ uint16_t nb_rx_queue_stats_mappings = 0;
*/
uint8_t xstats_hide_zero;
/*
* Measure of CPU cycles disabled by default
*/
uint8_t record_core_cycles;
unsigned int num_sockets = 0;
unsigned int socket_ids[RTE_MAX_NUMA_NODES];
@ -1800,9 +1805,7 @@ fwd_stats_display(void)
uint64_t total_tx_dropped = 0;
uint64_t total_rx_nombuf = 0;
struct rte_eth_stats stats;
#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
uint64_t fwd_cycles = 0;
#endif
uint64_t total_recv = 0;
uint64_t total_xmit = 0;
struct rte_port *port;
@ -1830,9 +1833,8 @@ fwd_stats_display(void)
ports_stats[fs->rx_port].rx_bad_outer_l4_csum +=
fs->rx_bad_outer_l4_csum;
#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
fwd_cycles += fs->core_cycles;
#endif
if (record_core_cycles)
fwd_cycles += fs->core_cycles;
}
for (i = 0; i < cur_fwd_config.nb_fwd_ports; i++) {
uint8_t j;
@ -1961,24 +1963,24 @@ fwd_stats_display(void)
printf(" %s++++++++++++++++++++++++++++++++++++++++++++++"
"%s\n",
acc_stats_border, acc_stats_border);
#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
if (record_core_cycles) {
#define CYC_PER_MHZ 1E6
if (total_recv > 0 || total_xmit > 0) {
uint64_t total_pkts = 0;
if (strcmp(cur_fwd_eng->fwd_mode_name, "txonly") == 0 ||
strcmp(cur_fwd_eng->fwd_mode_name, "flowgen") == 0)
total_pkts = total_xmit;
else
total_pkts = total_recv;
if (total_recv > 0 || total_xmit > 0) {
uint64_t total_pkts = 0;
if (strcmp(cur_fwd_eng->fwd_mode_name, "txonly") == 0 ||
strcmp(cur_fwd_eng->fwd_mode_name, "flowgen") == 0)
total_pkts = total_xmit;
else
total_pkts = total_recv;
printf("\n CPU cycles/packet=%.2F (total cycles="
"%"PRIu64" / total %s packets=%"PRIu64") at %"PRIu64
" MHz Clock\n",
(double) fwd_cycles / total_pkts,
fwd_cycles, cur_fwd_eng->fwd_mode_name, total_pkts,
(uint64_t)(rte_get_tsc_hz() / CYC_PER_MHZ));
printf("\n CPU cycles/packet=%.2F (total cycles="
"%"PRIu64" / total %s packets=%"PRIu64") at %"PRIu64
" MHz Clock\n",
(double) fwd_cycles / total_pkts,
fwd_cycles, cur_fwd_eng->fwd_mode_name, total_pkts,
(uint64_t)(rte_get_tsc_hz() / CYC_PER_MHZ));
}
}
#endif
}
void
@ -2006,9 +2008,7 @@ fwd_stats_reset(void)
memset(&fs->rx_burst_stats, 0, sizeof(fs->rx_burst_stats));
memset(&fs->tx_burst_stats, 0, sizeof(fs->tx_burst_stats));
#endif
#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
fs->core_cycles = 0;
#endif
}
}

18
app/test-pmd/testpmd.h
View File

@ -129,9 +129,7 @@ struct fwd_stream {
uint64_t rx_bad_outer_l4_csum;
/**< received packets has bad outer l4 checksum */
unsigned int gro_times; /**< GRO operation times */
#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
uint64_t core_cycles; /**< used for RX and TX processing */
#endif
#ifdef RTE_TEST_PMD_RECORD_BURST_STATS
struct pkt_burst_stats rx_burst_stats;
struct pkt_burst_stats tx_burst_stats;
@ -301,6 +299,7 @@ extern uint16_t nb_rx_queue_stats_mappings;
extern uint8_t xstats_hide_zero; /**< Hide zero values for xstats display */
/* globals used for configuration */
extern uint8_t record_core_cycles; /**< Enables measurement of CPU cycles */
extern uint16_t verbose_level; /**< Drives messages being displayed, if any. */
extern int testpmd_logtype; /**< Log type for testpmd logs */
extern uint8_t interactive;
@ -681,6 +680,20 @@ port_pci_reg_write(struct rte_port *port, uint32_t reg_off, uint32_t reg_v)
#define port_id_pci_reg_write(pt_id, reg_off, reg_value) \
port_pci_reg_write(&ports[(pt_id)], (reg_off), (reg_value))
static inline void
get_start_cycles(uint64_t *start_tsc)
{
if (record_core_cycles)
*start_tsc = rte_rdtsc();
}
static inline void
get_end_cycles(struct fwd_stream *fs, uint64_t start_tsc)
{
if (record_core_cycles)
fs->core_cycles += rte_rdtsc() - start_tsc;
}
/* Prototypes */
unsigned int parse_item_list(char* str, const char* item_name,
unsigned int max_items,
@ -772,6 +785,7 @@ void set_qmap(portid_t port_id, uint8_t is_rx, uint16_t queue_id, uint8_t map_va
void set_xstats_hide_zero(uint8_t on_off);
void set_record_core_cycles(uint8_t on_off);
void set_verbose_level(uint16_t vb_level);
void set_tx_pkt_segments(unsigned *seg_lengths, unsigned nb_segs);
void show_tx_pkt_segments(void);

16
app/test-pmd/txonly.c
View File

@ -299,15 +299,9 @@ pkt_burst_transmit(struct fwd_stream *fs)
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;
#endif
uint64_t start_tsc = 0;
#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
start_tsc = rte_rdtsc();
#endif
get_start_cycles(&start_tsc);
mbp = current_fwd_lcore()->mbp;
txp = &ports[fs->tx_port];
@ -396,11 +390,7 @@ pkt_burst_transmit(struct fwd_stream *fs)
} 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
get_end_cycles(fs, start_tsc);
}
static void

4
doc/guides/testpmd_app_ug/run_app.rst
View File

@ -489,3 +489,7 @@ The command line options are:
The default value is 0x7::
ETH_MQ_RX_RSS_FLAG | ETH_MQ_RX_DCB_FLAG | ETH_MQ_RX_VMDQ_FLAG
* ``--record-core-cycles``
Enable measurement of CPU cycles per packet.

15
doc/guides/testpmd_app_ug/testpmd_funcs.rst
View File

@ -710,6 +710,21 @@ Set the forwarding ports hexadecimal mask::
This is equivalent to the ``--portmask`` command-line option.
set record-core-cycles
~~~~~~~~~~~~~~~~~~~~~~
Set the recording of CPU cycles::
testpmd> set record-core-cycles (on|off)
Where:
* ``on`` enables measurement of CPU cycles per packet.
* ``off`` disables measurement of CPU cycles per packet.
This is equivalent to the ``--record-core-cycles command-line`` option.
set burst
~~~~~~~~~