#include <rte_spinlock.h>
#include <rte_power_empty_poll.h>
#include <rte_metrics.h>
-#ifdef RTE_LIBRTE_TELEMETRY
#include <rte_telemetry.h>
-#endif
#include "perf_core.h"
#include "main.h"
/**< disabled by default */
enum appmode {
- APP_MODE_LEGACY = 0,
+ APP_MODE_DEFAULT = 0,
+ APP_MODE_LEGACY,
APP_MODE_EMPTY_POLL,
APP_MODE_TELEMETRY
};
},
.txmode = {
.mq_mode = ETH_MQ_TX_NONE,
- },
- .intr_conf = {
- .rxq = 1,
- },
+ }
};
static struct rte_mempool * pktmbuf_pool[NB_SOCKETS];
static int
sleep_until_rx_interrupt(int num)
{
+ /*
+ * we want to track when we are woken up by traffic so that we can go
+ * back to sleep again without log spamming.
+ */
+ static bool timeout;
struct rte_epoll_event event[num];
int n, i;
uint16_t port_id;
uint8_t queue_id;
void *data;
- RTE_LOG(INFO, L3FWD_POWER,
- "lcore %u sleeps until interrupt triggers\n",
- rte_lcore_id());
+ if (!timeout) {
+ RTE_LOG(INFO, L3FWD_POWER,
+ "lcore %u sleeps until interrupt triggers\n",
+ rte_lcore_id());
+ }
- n = rte_epoll_wait(RTE_EPOLL_PER_THREAD, event, num, -1);
+ n = rte_epoll_wait(RTE_EPOLL_PER_THREAD, event, num, 10);
for (i = 0; i < n; i++) {
data = event[i].epdata.data;
port_id = ((uintptr_t)data) >> CHAR_BIT;
" port %d queue %d\n",
rte_lcore_id(), port_id, queue_id);
}
+ timeout = n == 0;
return 0;
}
}
/* main processing loop */
static int
-main_loop(__rte_unused void *dummy)
+main_legacy_loop(__rte_unused void *dummy)
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
unsigned lcore_id;
/**
* start receiving packets immediately
*/
- goto start_rx;
+ if (likely(!is_done()))
+ goto start_rx;
}
}
stats[lcore_id].sleep_time += lcore_idle_hint;
" --enable-jumbo: enable jumbo frame"
" which max packet len is PKTLEN in decimal (64-9600)\n"
" --parse-ptype: parse packet type by software\n"
+ " --legacy: use legacy interrupt-based scaling\n"
" --empty-poll: enable empty poll detection"
" follow (training_flag, high_threshold, med_threshold)\n"
" --telemetry: enable telemetry mode, to update"
}
#define CMD_LINE_OPT_PARSE_PTYPE "parse-ptype"
+#define CMD_LINE_OPT_LEGACY "legacy"
+#define CMD_LINE_OPT_EMPTY_POLL "empty-poll"
#define CMD_LINE_OPT_TELEMETRY "telemetry"
/* Parse the argument given in the command line of the application */
{"high-perf-cores", 1, 0, 0},
{"no-numa", 0, 0, 0},
{"enable-jumbo", 0, 0, 0},
- {"empty-poll", 1, 0, 0},
+ {CMD_LINE_OPT_EMPTY_POLL, 1, 0, 0},
{CMD_LINE_OPT_PARSE_PTYPE, 0, 0, 0},
+ {CMD_LINE_OPT_LEGACY, 0, 0, 0},
{CMD_LINE_OPT_TELEMETRY, 0, 0, 0},
{NULL, 0, 0, 0}
};
}
if (!strncmp(lgopts[option_index].name,
- "empty-poll", 10)) {
- if (app_mode == APP_MODE_TELEMETRY) {
- printf(" empty-poll cannot be enabled as telemetry mode is enabled\n");
+ CMD_LINE_OPT_LEGACY,
+ sizeof(CMD_LINE_OPT_LEGACY))) {
+ if (app_mode != APP_MODE_DEFAULT) {
+ printf(" legacy mode is mutually exclusive with other modes\n");
+ return -1;
+ }
+ app_mode = APP_MODE_LEGACY;
+ printf("legacy mode is enabled\n");
+ }
+
+ if (!strncmp(lgopts[option_index].name,
+ CMD_LINE_OPT_EMPTY_POLL, 10)) {
+ if (app_mode != APP_MODE_DEFAULT) {
+ printf(" empty-poll mode is mutually exclusive with other modes\n");
return -1;
}
app_mode = APP_MODE_EMPTY_POLL;
if (!strncmp(lgopts[option_index].name,
CMD_LINE_OPT_TELEMETRY,
sizeof(CMD_LINE_OPT_TELEMETRY))) {
- if (app_mode == APP_MODE_EMPTY_POLL) {
- printf("telemetry mode cannot be enabled as empty poll mode is enabled\n");
+ if (app_mode != APP_MODE_DEFAULT) {
+ printf(" telemetry mode is mutually exclusive with other modes\n");
return -1;
}
app_mode = APP_MODE_TELEMETRY;
"Mbps - %s\n", (uint8_t)portid,
(unsigned)link.link_speed,
(link.link_duplex == ETH_LINK_FULL_DUPLEX) ?
- ("full-duplex") : ("half-duplex\n"));
+ ("full-duplex") : ("half-duplex"));
else
printf("Port %d Link Down\n",
(uint8_t)portid);
static int
init_power_library(void)
{
+ enum power_management_env env;
unsigned int lcore_id;
int ret = 0;
lcore_id);
return ret;
}
+ /* we're not supporting the VM channel mode */
+ env = rte_power_get_env();
+ if (env != PM_ENV_ACPI_CPUFREQ &&
+ env != PM_ENV_PSTATE_CPUFREQ) {
+ RTE_LOG(ERR, POWER,
+ "Only ACPI and PSTATE mode are supported\n");
+ return -1;
+ }
}
return ret;
}
if (ret < 0)
RTE_LOG(WARNING, POWER, "failed to update metrcis\n");
}
-#ifdef RTE_LIBRTE_TELEMETRY
+
static int
handle_app_stats(const char *cmd __rte_unused,
const char *params __rte_unused,
values[i]);
return 0;
}
-#endif
+
static void
telemetry_setup_timer(void)
{
if (ret < 0)
rte_exit(EXIT_FAILURE, "Invalid L3FWD parameters\n");
- if (app_mode != APP_MODE_TELEMETRY && init_power_library())
+ if (app_mode == APP_MODE_DEFAULT)
+ app_mode = APP_MODE_LEGACY;
+
+ /* only legacy and empty poll mode rely on power library */
+ if ((app_mode == APP_MODE_LEGACY || app_mode == APP_MODE_EMPTY_POLL) &&
+ init_power_library())
rte_exit(EXIT_FAILURE, "init_power_library failed\n");
if (update_lcore_params() < 0)
/* initialize all ports */
RTE_ETH_FOREACH_DEV(portid) {
struct rte_eth_conf local_port_conf = port_conf;
+ /* not all app modes need interrupts */
+ bool need_intr = app_mode == APP_MODE_LEGACY;
/* skip ports that are not enabled */
if ((enabled_port_mask & (1 << portid)) == 0) {
nb_rx_queue, (unsigned)n_tx_queue );
/* If number of Rx queue is 0, no need to enable Rx interrupt */
if (nb_rx_queue == 0)
- local_port_conf.intr_conf.rxq = 0;
+ need_intr = false;
+
+ if (need_intr)
+ local_port_conf.intr_conf.rxq = 1;
ret = rte_eth_dev_info_get(portid, &dev_info);
if (ret != 0)
/* launch per-lcore init on every lcore */
if (app_mode == APP_MODE_LEGACY) {
- rte_eal_mp_remote_launch(main_loop, NULL, CALL_MASTER);
+ rte_eal_mp_remote_launch(main_legacy_loop, NULL, CALL_MASTER);
} else if (app_mode == APP_MODE_EMPTY_POLL) {
empty_poll_stop = false;
rte_eal_mp_remote_launch(main_empty_poll_loop, NULL,
SKIP_MASTER);
- } else {
+ } else if (app_mode == APP_MODE_TELEMETRY) {
unsigned int i;
/* Init metrics library */
rte_spinlock_init(&stats[lcore_id].telemetry_lock);
}
rte_timer_init(&telemetry_timer);
-#ifdef RTE_LIBRTE_TELEMETRY
rte_telemetry_register_cmd("/l3fwd-power/stats",
handle_app_stats,
"Returns global power stats. Parameters: None");
-#endif
rte_eal_mp_remote_launch(main_telemetry_loop, NULL,
SKIP_MASTER);
}
if (app_mode == APP_MODE_EMPTY_POLL)
rte_power_empty_poll_stat_free();
- if (app_mode != APP_MODE_TELEMETRY && deinit_power_library())
+ if ((app_mode == APP_MODE_LEGACY || app_mode == APP_MODE_EMPTY_POLL) &&
+ deinit_power_library())
rte_exit(EXIT_FAILURE, "deinit_power_library failed\n");
if (rte_eal_cleanup() < 0)