#include <rte_memcpy.h>
#include <rte_eal.h>
#include <rte_launch.h>
-#include <rte_atomic.h>
#include <rte_cycles.h>
#include <rte_prefetch.h>
#include <rte_lcore.h>
#include <rte_power_empty_poll.h>
#include <rte_metrics.h>
#include <rte_telemetry.h>
+#include <rte_power_pmd_mgmt.h>
#include "perf_core.h"
#include "main.h"
APP_MODE_LEGACY,
APP_MODE_EMPTY_POLL,
APP_MODE_TELEMETRY,
- APP_MODE_INTERRUPT
+ APP_MODE_INTERRUPT,
+ APP_MODE_PMD_MGMT
};
enum appmode app_mode;
+static enum rte_power_pmd_mgmt_type pmgmt_type;
+bool baseline_enabled;
+
enum freq_scale_hint_t
{
FREQ_LOWER = -1,
static struct rte_eth_conf port_conf = {
.rxmode = {
- .mq_mode = ETH_MQ_RX_RSS,
- .max_rx_pkt_len = RTE_ETHER_MAX_LEN,
+ .mq_mode = RTE_ETH_MQ_RX_RSS,
.split_hdr_size = 0,
- .offloads = DEV_RX_OFFLOAD_CHECKSUM,
+ .offloads = RTE_ETH_RX_OFFLOAD_CHECKSUM,
},
.rx_adv_conf = {
.rss_conf = {
.rss_key = NULL,
- .rss_hf = ETH_RSS_UDP,
+ .rss_hf = RTE_ETH_RSS_UDP,
},
},
.txmode = {
- .mq_mode = ETH_MQ_TX_NONE,
+ .mq_mode = RTE_ETH_MQ_TX_NONE,
}
};
+static uint32_t max_pkt_len;
+static uint32_t max_empty_polls = 512;
+static uint32_t pause_duration = 1;
+static uint32_t scale_freq_min;
+static uint32_t scale_freq_max;
+
static struct rte_mempool * pktmbuf_pool[NB_SOCKETS];
}
-/* Freqency scale down timer callback */
+/* Frequency scale down timer callback */
static void
power_timer_cb(__rte_unused struct rte_timer *tim,
__rte_unused void *arg)
return -1;
/* 2. The IP checksum must be correct. */
- /* this is checked in H/W */
+ /* if this is not checked in H/W, check it. */
+ if ((port_conf.rxmode.offloads & RTE_ETH_RX_OFFLOAD_IPV4_CKSUM) == 0) {
+ uint16_t actual_cksum, expected_cksum;
+ actual_cksum = pkt->hdr_checksum;
+ pkt->hdr_checksum = 0;
+ expected_cksum = rte_ipv4_cksum(pkt);
+ if (actual_cksum != expected_cksum)
+ return -2;
+ }
/*
* 3. The IP version number must be 4. If the version number is not 4
dst_port = portid;
/* 02:00:00:00:00:xx */
- d_addr_bytes = ð_hdr->d_addr.addr_bytes[0];
+ d_addr_bytes = ð_hdr->dst_addr.addr_bytes[0];
*((uint64_t *)d_addr_bytes) =
0x000000000002 + ((uint64_t)dst_port << 40);
/* src addr */
rte_ether_addr_copy(&ports_eth_addr[dst_port],
- ð_hdr->s_addr);
+ ð_hdr->src_addr);
send_single_packet(m, dst_port);
} else if (RTE_ETH_IS_IPV6_HDR(m->packet_type)) {
dst_port = portid;
/* 02:00:00:00:00:xx */
- d_addr_bytes = ð_hdr->d_addr.addr_bytes[0];
+ d_addr_bytes = ð_hdr->dst_addr.addr_bytes[0];
*((uint64_t *)d_addr_bytes) =
0x000000000002 + ((uint64_t)dst_port << 40);
/* src addr */
rte_ether_addr_copy(&ports_eth_addr[dst_port],
- ð_hdr->s_addr);
+ ð_hdr->src_addr);
send_single_packet(m, dst_port);
#else
* 0 on success
*/
static int
-sleep_until_rx_interrupt(int num)
+sleep_until_rx_interrupt(int num, int lcore)
{
/*
* we want to track when we are woken up by traffic so that we can go
- * back to sleep again without log spamming.
+ * back to sleep again without log spamming. Avoid cache line sharing
+ * to prevent threads stepping on each others' toes.
*/
- static bool timeout;
+ static struct {
+ bool wakeup;
+ } __rte_cache_aligned status[RTE_MAX_LCORE];
struct rte_epoll_event event[num];
int n, i;
uint16_t port_id;
uint8_t queue_id;
void *data;
- if (!timeout) {
+ if (status[lcore].wakeup) {
RTE_LOG(INFO, L3FWD_POWER,
"lcore %u sleeps until interrupt triggers\n",
rte_lcore_id());
" port %d queue %d\n",
rte_lcore_id(), port_id, queue_id);
}
- timeout = n == 0;
+ status[lcore].wakeup = n != 0;
return 0;
}
return 0;
}
-/* main processing loop */
+/* Main processing loop. 8< */
static int main_intr_loop(__rte_unused void *dummy)
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
if (intr_en) {
turn_on_off_intr(qconf, 1);
sleep_until_rx_interrupt(
- qconf->n_rx_queue);
+ qconf->n_rx_queue,
+ lcore_id);
turn_on_off_intr(qconf, 0);
/**
* start receiving packets immediately
return 0;
}
+/* >8 End of main processing loop. */
/* main processing loop */
static int
if (intr_en) {
turn_on_off_intr(qconf, 1);
sleep_until_rx_interrupt(
- qconf->n_rx_queue);
+ qconf->n_rx_queue,
+ lcore_id);
turn_on_off_intr(qconf, 0);
/**
* start receiving packets immediately
"off\n", lcore, socketid);
}
if (app_mode == APP_MODE_TELEMETRY && lcore == rte_lcore_id()) {
- printf("cannot enable master core %d in config for telemetry mode\n",
+ printf("cannot enable main core %d in config for telemetry mode\n",
rte_lcore_id());
return -1;
}
" [--config (port,queue,lcore)[,(port,queue,lcore]]"
" [--high-perf-cores CORELIST"
" [--perf-config (port,queue,hi_perf,lcore_index)[,(port,queue,hi_perf,lcore_index]]"
- " [--enable-jumbo [--max-pkt-len PKTLEN]]\n"
+ " [--max-pkt-len PKTLEN]\n"
" -p PORTMASK: hexadecimal bitmask of ports to configure\n"
- " -P : enable promiscuous mode\n"
+ " -P: enable promiscuous mode\n"
" --config (port,queue,lcore): rx queues configuration\n"
" --high-perf-cores CORELIST: list of high performance cores\n"
" --perf-config: similar as config, cores specified as indices"
" for bins containing high or regular performance cores\n"
" --no-numa: optional, disable numa awareness\n"
- " --enable-jumbo: enable jumbo frame"
- " which max packet len is PKTLEN in decimal (64-9600)\n"
+ " --max-pkt-len PKTLEN: maximum packet length 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"
" empty polls, full polls, and core busyness to telemetry\n"
- " --interrupt-only: enable interrupt-only mode\n",
+ " --interrupt-only: enable interrupt-only mode\n"
+ " --pmd-mgmt MODE: enable PMD power management mode. "
+ "Currently supported modes: baseline, monitor, pause, scale\n"
+ " --max-empty-polls MAX_EMPTY_POLLS: number of empty polls to"
+ " wait before entering sleep state\n"
+ " --pause-duration DURATION: set the duration, in microseconds,"
+ " of the pause callback\n"
+ " --scale-freq-min FREQ_MIN: set minimum frequency for scaling mode for"
+ " all application lcores (FREQ_MIN must be in kHz, in increments of 100MHz)\n"
+ " --scale-freq-max FREQ_MAX: set maximum frequency for scaling mode for"
+ " all application lcores (FREQ_MAX must be in kHz, in increments of 100MHz)\n",
prgname);
}
+static int
+parse_int(const char *opt)
+{
+ char *end = NULL;
+ unsigned long val;
+
+ /* parse integer string */
+ val = strtoul(opt, &end, 10);
+ if ((opt[0] == '\0') || (end == NULL) || (*end != '\0'))
+ return -1;
+
+ return val;
+}
+
static int parse_max_pkt_len(const char *pktlen)
{
char *end = NULL;
return 0;
}
+
+static int
+parse_pmd_mgmt_config(const char *name)
+{
+#define PMD_MGMT_MONITOR "monitor"
+#define PMD_MGMT_PAUSE "pause"
+#define PMD_MGMT_SCALE "scale"
+#define PMD_MGMT_BASELINE "baseline"
+
+ if (strncmp(PMD_MGMT_MONITOR, name, sizeof(PMD_MGMT_MONITOR)) == 0) {
+ pmgmt_type = RTE_POWER_MGMT_TYPE_MONITOR;
+ return 0;
+ }
+
+ if (strncmp(PMD_MGMT_PAUSE, name, sizeof(PMD_MGMT_PAUSE)) == 0) {
+ pmgmt_type = RTE_POWER_MGMT_TYPE_PAUSE;
+ return 0;
+ }
+
+ if (strncmp(PMD_MGMT_SCALE, name, sizeof(PMD_MGMT_SCALE)) == 0) {
+ pmgmt_type = RTE_POWER_MGMT_TYPE_SCALE;
+ return 0;
+ }
+ if (strncmp(PMD_MGMT_BASELINE, name, sizeof(PMD_MGMT_BASELINE)) == 0) {
+ baseline_enabled = true;
+ return 0;
+ }
+ /* unknown PMD power management mode */
+ return -1;
+}
+
static int
parse_ep_config(const char *q_arg)
{
int hgh_edpi;
ep_med_edpi = EMPTY_POLL_MED_THRESHOLD;
- ep_hgh_edpi = EMPTY_POLL_MED_THRESHOLD;
+ ep_hgh_edpi = EMPTY_POLL_HGH_THRESHOLD;
strlcpy(s, p, sizeof(s));
if (med_edpi > 0)
ep_med_edpi = med_edpi;
- if (med_edpi > 0)
+ if (hgh_edpi > 0)
ep_hgh_edpi = hgh_edpi;
} else {
#define CMD_LINE_OPT_EMPTY_POLL "empty-poll"
#define CMD_LINE_OPT_INTERRUPT_ONLY "interrupt-only"
#define CMD_LINE_OPT_TELEMETRY "telemetry"
+#define CMD_LINE_OPT_PMD_MGMT "pmd-mgmt"
+#define CMD_LINE_OPT_MAX_PKT_LEN "max-pkt-len"
+#define CMD_LINE_OPT_MAX_EMPTY_POLLS "max-empty-polls"
+#define CMD_LINE_OPT_PAUSE_DURATION "pause-duration"
+#define CMD_LINE_OPT_SCALE_FREQ_MIN "scale-freq-min"
+#define CMD_LINE_OPT_SCALE_FREQ_MAX "scale-freq-max"
/* Parse the argument given in the command line of the application */
static int
{"perf-config", 1, 0, 0},
{"high-perf-cores", 1, 0, 0},
{"no-numa", 0, 0, 0},
- {"enable-jumbo", 0, 0, 0},
+ {CMD_LINE_OPT_MAX_PKT_LEN, 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},
{CMD_LINE_OPT_INTERRUPT_ONLY, 0, 0, 0},
+ {CMD_LINE_OPT_PMD_MGMT, 1, 0, 0},
+ {CMD_LINE_OPT_MAX_EMPTY_POLLS, 1, 0, 0},
+ {CMD_LINE_OPT_PAUSE_DURATION, 1, 0, 0},
+ {CMD_LINE_OPT_SCALE_FREQ_MIN, 1, 0, 0},
+ {CMD_LINE_OPT_SCALE_FREQ_MAX, 1, 0, 0},
{NULL, 0, 0, 0}
};
printf("telemetry mode is enabled\n");
}
+ if (!strncmp(lgopts[option_index].name,
+ CMD_LINE_OPT_PMD_MGMT,
+ sizeof(CMD_LINE_OPT_PMD_MGMT))) {
+ if (app_mode != APP_MODE_DEFAULT) {
+ printf(" power mgmt mode is mutually exclusive with other modes\n");
+ return -1;
+ }
+ if (parse_pmd_mgmt_config(optarg) < 0) {
+ printf(" Invalid PMD power management mode: %s\n",
+ optarg);
+ return -1;
+ }
+ app_mode = APP_MODE_PMD_MGMT;
+ printf("PMD power mgmt mode is enabled\n");
+ }
if (!strncmp(lgopts[option_index].name,
CMD_LINE_OPT_INTERRUPT_ONLY,
sizeof(CMD_LINE_OPT_INTERRUPT_ONLY))) {
}
if (!strncmp(lgopts[option_index].name,
- "enable-jumbo", 12)) {
- struct option lenopts =
- {"max-pkt-len", required_argument, \
- 0, 0};
-
- printf("jumbo frame is enabled \n");
- port_conf.rxmode.offloads |=
- DEV_RX_OFFLOAD_JUMBO_FRAME;
- port_conf.txmode.offloads |=
- DEV_TX_OFFLOAD_MULTI_SEGS;
-
- /**
- * if no max-pkt-len set, use the default value
- * RTE_ETHER_MAX_LEN
- */
- if (0 == getopt_long(argc, argvopt, "",
- &lenopts, &option_index)) {
- ret = parse_max_pkt_len(optarg);
- if ((ret < 64) ||
- (ret > MAX_JUMBO_PKT_LEN)){
- printf("invalid packet "
- "length\n");
- print_usage(prgname);
- return -1;
- }
- port_conf.rxmode.max_rx_pkt_len = ret;
- }
- printf("set jumbo frame "
- "max packet length to %u\n",
- (unsigned int)port_conf.rxmode.max_rx_pkt_len);
+ CMD_LINE_OPT_MAX_PKT_LEN,
+ sizeof(CMD_LINE_OPT_MAX_PKT_LEN))) {
+ printf("Custom frame size is configured\n");
+ max_pkt_len = parse_max_pkt_len(optarg);
}
if (!strncmp(lgopts[option_index].name,
parse_ptype = 1;
}
+ if (!strncmp(lgopts[option_index].name,
+ CMD_LINE_OPT_MAX_EMPTY_POLLS,
+ sizeof(CMD_LINE_OPT_MAX_EMPTY_POLLS))) {
+ printf("Maximum empty polls configured\n");
+ max_empty_polls = parse_int(optarg);
+ }
+
+ if (!strncmp(lgopts[option_index].name,
+ CMD_LINE_OPT_PAUSE_DURATION,
+ sizeof(CMD_LINE_OPT_PAUSE_DURATION))) {
+ printf("Pause duration configured\n");
+ pause_duration = parse_int(optarg);
+ }
+
+ if (!strncmp(lgopts[option_index].name,
+ CMD_LINE_OPT_SCALE_FREQ_MIN,
+ sizeof(CMD_LINE_OPT_SCALE_FREQ_MIN))) {
+ printf("Scaling frequency minimum configured\n");
+ scale_freq_min = parse_int(optarg);
+ }
+
+ if (!strncmp(lgopts[option_index].name,
+ CMD_LINE_OPT_SCALE_FREQ_MAX,
+ sizeof(CMD_LINE_OPT_SCALE_FREQ_MAX))) {
+ printf("Scaling frequency maximum configured\n");
+ scale_freq_max = parse_int(optarg);
+ }
+
break;
default:
continue;
}
/* clear all_ports_up flag if any link down */
- if (link.link_status == ETH_LINK_DOWN) {
+ if (link.link_status == RTE_ETH_LINK_DOWN) {
all_ports_up = 0;
break;
}
uint64_t app_eps = 0, app_fps = 0, app_br = 0;
uint64_t count = 0;
- RTE_LCORE_FOREACH_SLAVE(lcore_id) {
+ RTE_LCORE_FOREACH_WORKER(lcore_id) {
qconf = &lcore_conf[lcore_id];
if (qconf->n_rx_queue == 0)
continue;
ret = rte_metrics_update_values(RTE_METRICS_GLOBAL, telstats_index,
values, RTE_DIM(values));
if (ret < 0)
- RTE_LOG(WARNING, POWER, "failed to update metrcis\n");
+ RTE_LOG(WARNING, POWER, "failed to update metrics\n");
}
static int
RTE_SET_USED(lcore_id);
- if (rte_get_master_lcore() != lcore_id) {
- rte_panic("timer on lcore:%d which is not master core:%d\n",
+ if (rte_get_main_lcore() != lcore_id) {
+ rte_panic("timer on lcore:%d which is not main core:%d\n",
lcore_id,
- rte_get_master_lcore());
+ rte_get_main_lcore());
}
RTE_LOG(INFO, POWER, "Bring up the Timer\n");
return "telemetry";
case APP_MODE_INTERRUPT:
return "interrupt-only";
+ case APP_MODE_PMD_MGMT:
+ return "pmd mgmt";
default:
return "invalid";
}
}
+static uint32_t
+eth_dev_get_overhead_len(uint32_t max_rx_pktlen, uint16_t max_mtu)
+{
+ uint32_t overhead_len;
+
+ if (max_mtu != UINT16_MAX && max_rx_pktlen > max_mtu)
+ overhead_len = max_rx_pktlen - max_mtu;
+ else
+ overhead_len = RTE_ETHER_HDR_LEN + RTE_ETHER_CRC_LEN;
+
+ return overhead_len;
+}
+
+static int
+config_port_max_pkt_len(struct rte_eth_conf *conf,
+ struct rte_eth_dev_info *dev_info)
+{
+ uint32_t overhead_len;
+
+ if (max_pkt_len == 0)
+ return 0;
+
+ if (max_pkt_len < RTE_ETHER_MIN_LEN || max_pkt_len > MAX_JUMBO_PKT_LEN)
+ return -1;
+
+ overhead_len = eth_dev_get_overhead_len(dev_info->max_rx_pktlen,
+ dev_info->max_mtu);
+ conf->rxmode.mtu = max_pkt_len - overhead_len;
+
+ if (conf->rxmode.mtu > RTE_ETHER_MTU)
+ conf->txmode.offloads |= RTE_ETH_TX_OFFLOAD_MULTI_SEGS;
+
+ return 0;
+}
+
+/* Power library initialized in the main routine. 8< */
int
main(int argc, char **argv)
{
uint16_t portid;
const char *ptr_strings[NUM_TELSTATS];
- /* catch SIGINT and restore cpufreq governor to ondemand */
- signal(SIGINT, signal_exit_now);
-
/* init EAL */
ret = rte_eal_init(argc, argv);
if (ret < 0)
argc -= ret;
argv += ret;
+ /* catch SIGINT and restore cpufreq governor to ondemand */
+ signal(SIGINT, signal_exit_now);
+
/* init RTE timer library to be used late */
rte_timer_subsystem_init();
+ /* if we're running pmd-mgmt mode, don't default to baseline mode */
+ baseline_enabled = false;
+
/* parse application arguments (after the EAL ones) */
ret = parse_args(argc, argv);
if (ret < 0)
"Error during getting device (port %u) info: %s\n",
portid, strerror(-ret));
- if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE)
+ ret = config_port_max_pkt_len(&local_port_conf, &dev_info);
+ if (ret != 0)
+ rte_exit(EXIT_FAILURE,
+ "Invalid max packet length: %u (port %u)\n",
+ max_pkt_len, portid);
+
+ if (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_MBUF_FAST_FREE)
local_port_conf.txmode.offloads |=
- DEV_TX_OFFLOAD_MBUF_FAST_FREE;
+ RTE_ETH_TX_OFFLOAD_MBUF_FAST_FREE;
local_port_conf.rx_adv_conf.rss_conf.rss_hf &=
dev_info.flow_type_rss_offloads;
local_port_conf.rx_adv_conf.rss_conf.rss_hf);
}
+ if (local_port_conf.rx_adv_conf.rss_conf.rss_hf == 0)
+ local_port_conf.rxmode.mq_mode = RTE_ETH_MQ_RX_NONE;
+ local_port_conf.rxmode.offloads &= dev_info.rx_offload_capa;
+ port_conf.rxmode.offloads = local_port_conf.rxmode.offloads;
+
ret = rte_eth_dev_configure(portid, nb_rx_queue,
(uint16_t)n_tx_queue, &local_port_conf);
if (ret < 0)
qconf = &lcore_conf[lcore_id];
printf("\nInitializing rx queues on lcore %u ... ", lcore_id );
fflush(stdout);
+
/* init RX queues */
for(queue = 0; queue < qconf->n_rx_queue; ++queue) {
struct rte_eth_rxconf rxq_conf;
if (add_cb_parse_ptype(portid, queueid) < 0)
rte_exit(EXIT_FAILURE,
"Fail to add ptype cb\n");
- } else if (!check_ptype(portid))
- rte_exit(EXIT_FAILURE,
- "PMD can not provide needed ptypes\n");
+ }
+
+ if (app_mode == APP_MODE_PMD_MGMT && !baseline_enabled) {
+ /* Set power_pmd_mgmt configs passed by user */
+ rte_power_pmd_mgmt_set_emptypoll_max(max_empty_polls);
+ ret = rte_power_pmd_mgmt_set_pause_duration(pause_duration);
+ if (ret < 0)
+ rte_exit(EXIT_FAILURE,
+ "Error setting pause_duration: err=%d, lcore=%d\n",
+ ret, lcore_id);
+
+ ret = rte_power_pmd_mgmt_set_scaling_freq_min(lcore_id,
+ scale_freq_min);
+ if (ret < 0)
+ rte_exit(EXIT_FAILURE,
+ "Error setting scaling freq min: err=%d, lcore=%d\n",
+ ret, lcore_id);
+
+ ret = rte_power_pmd_mgmt_set_scaling_freq_max(lcore_id,
+ scale_freq_max);
+ if (ret < 0)
+ rte_exit(EXIT_FAILURE,
+ "Error setting scaling freq max: err=%d, lcore %d\n",
+ ret, lcore_id);
+
+ ret = rte_power_ethdev_pmgmt_queue_enable(
+ lcore_id, portid, queueid,
+ pmgmt_type);
+ if (ret < 0)
+ rte_exit(EXIT_FAILURE,
+ "rte_power_ethdev_pmgmt_queue_enable: err=%d, port=%d\n",
+ ret, portid);
+ }
}
}
+ /* >8 End of power library initialization. */
printf("\n");
}
/* initialize spinlock for each port */
rte_spinlock_init(&(locks[portid]));
+
+ if (!parse_ptype)
+ if (!check_ptype(portid))
+ rte_exit(EXIT_FAILURE,
+ "PMD can not provide needed ptypes\n");
}
check_all_ports_link_status(enabled_port_mask);
/* launch per-lcore init on every lcore */
if (app_mode == APP_MODE_LEGACY) {
- rte_eal_mp_remote_launch(main_legacy_loop, NULL, CALL_MASTER);
+ rte_eal_mp_remote_launch(main_legacy_loop, NULL, CALL_MAIN);
} else if (app_mode == APP_MODE_EMPTY_POLL) {
empty_poll_stop = false;
rte_eal_mp_remote_launch(main_empty_poll_loop, NULL,
- SKIP_MASTER);
+ SKIP_MAIN);
} else if (app_mode == APP_MODE_TELEMETRY) {
unsigned int i;
else
rte_exit(EXIT_FAILURE, "failed to register metrics names");
- RTE_LCORE_FOREACH_SLAVE(lcore_id) {
+ RTE_LCORE_FOREACH_WORKER(lcore_id) {
rte_spinlock_init(&stats[lcore_id].telemetry_lock);
}
rte_timer_init(&telemetry_timer);
handle_app_stats,
"Returns global power stats. Parameters: None");
rte_eal_mp_remote_launch(main_telemetry_loop, NULL,
- SKIP_MASTER);
+ SKIP_MAIN);
} else if (app_mode == APP_MODE_INTERRUPT) {
- rte_eal_mp_remote_launch(main_intr_loop, NULL, CALL_MASTER);
+ rte_eal_mp_remote_launch(main_intr_loop, NULL, CALL_MAIN);
+ } else if (app_mode == APP_MODE_PMD_MGMT) {
+ /* reuse telemetry loop for PMD power management mode */
+ rte_eal_mp_remote_launch(main_telemetry_loop, NULL, CALL_MAIN);
}
if (app_mode == APP_MODE_EMPTY_POLL || app_mode == APP_MODE_TELEMETRY)
launch_timer(rte_lcore_id());
- RTE_LCORE_FOREACH_SLAVE(lcore_id) {
+ RTE_LCORE_FOREACH_WORKER(lcore_id) {
if (rte_eal_wait_lcore(lcore_id) < 0)
return -1;
}
+ if (app_mode == APP_MODE_PMD_MGMT) {
+ for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++) {
+ if (rte_lcore_is_enabled(lcore_id) == 0)
+ continue;
+ qconf = &lcore_conf[lcore_id];
+ for (queue = 0; queue < qconf->n_rx_queue; ++queue) {
+ portid = qconf->rx_queue_list[queue].port_id;
+ queueid = qconf->rx_queue_list[queue].queue_id;
+
+ rte_power_ethdev_pmgmt_queue_disable(lcore_id,
+ portid, queueid);
+ }
+ }
+ }
+
RTE_ETH_FOREACH_DEV(portid)
{
if ((enabled_port_mask & (1 << portid)) == 0)
continue;
- rte_eth_dev_stop(portid);
+ ret = rte_eth_dev_stop(portid);
+ if (ret != 0)
+ RTE_LOG(ERR, L3FWD_POWER, "rte_eth_dev_stop: err=%d, port=%u\n",
+ ret, portid);
+
rte_eth_dev_close(portid);
}
git.droids-corp.org / dpdk.git / blobdiff