dpdk应用场景系列06--rte_event使用(事件驱动）

rte_event 是 DPDK（Data Plane Development Kit）中的一个事件驱动框架，用于处理高性能数据包处理任务。它提供了一个灵活的事件调度机制，可以在多个核心之间高效地分配和处理网络事件。

事件设备和事件的关系

• 事件设备（Event Device）：
  事件设备是一个抽象层，用于管理事件的创建、调度和分发。
  事件设备可以配置多个事件队列（Event Queue）和事件端口（Event Port）。
• 事件队列（Event Queue）：
  事件队列用于存储和管理事件。
  每个事件队列可以配置不同的调度策略和优先级。
• 事件端口（Event Port）：
  事件端口用于从事件队列中取出事件（dequeue）和将事件放入事件队列（enqueue）。
  事件端口可以链接到多个事件队列，实现事件的高效分发。
• 事件（Event）：
  事件是数据包处理的基本单元，包含数据包的元数据和实际的数据包。
  事件可以在不同的事件队列和事件端口之间流动。

---

struct rte_event_dev_config：用于配置事件设备。

struct rte_event_dev_config {
    uint32_t dequeue_timeout_ns;          /**< 出队超时时间（纳秒）。 */
    uint32_t nb_events_limit;             /**< 设备可以容纳的最大事件数量。 */
    uint8_t nb_event_queues;              /**< 设备中的事件队列数量。 */
    uint8_t nb_event_ports;               /**< 设备中的事件端口数量。 */
    uint32_t nb_event_queue_flows;        /**< 每个事件队列的最大流数量。 */
    uint32_t nb_event_port_dequeue_depth; /**< 一次出队操作可以出队的最大事件数量。 */
    uint32_t nb_event_port_enqueue_depth; /**< 一次入队操作可以入队的最大事件数量。 */
};

struct rte_event_queue_conf：用于配置事件队列。

struct rte_event_queue_conf {
    uint32_t event_queue_cfg; /**< 事件队列配置标志。 */
    uint8_t schedule_type;    /**< 调度类型（原子、顺序或并行）。 */
    uint8_t priority;         /**< 事件队列的优先级。 */
};

struct rte_event_port_conf：用于配置事件端口。

struct rte_event_port_conf {
    int32_t new_event_threshold; /**< 新事件阈值。 */
    uint32_t dequeue_depth;      /**< 出队深度。 */
    uint32_t enqueue_depth;      /**< 入队深度。 */
};

rte_event_port_link：将事件端口与事件队列链接。

int rte_event_port_link(uint8_t dev_id, uint8_t port_id, const uint8_t queues[], const uint8_t priorities[], uint16_t nb_links);

rte_event_dequeue_burst：从事件设备中出队一批事件。

int rte_event_dequeue_burst(uint8_t dev_id, uint8_t port_id, struct rte_event *events, uint16_t nb_events, uint64_t timeout_ticks);

---

事件驱动模型与流量控制的区别

事件驱动模型
事件驱动模型是一种处理数据包的方式，它通过事件设备来调度和分发事件。事件驱动模型的主要特点和优势如下：

• 灵活性：
  事件驱动模型可以灵活地调度和分发事件，支持多种调度策略（如优先级调度、轮询调度等）。
  可以根据业务需求动态调整事件队列和端口的配置。
• 高效性：
  事件驱动模型可以在多个处理核心之间高效地分发事件，避免单个核心过载。
  支持多阶段处理流程，可以实现复杂的数据包处理逻辑。
• 可扩展性：
  事件驱动模型支持大规模的事件处理，可以处理大量的并发事件。
  通过配置多个事件队列和端口，可以实现高性能的负载均衡和流量控制。

流量控制
流量控制通常是指通过流规则（如 rte_flow）来管理和控制数据包的流动。流量控制的主要特点和优势如下：

• 精准控制：
  流量控制可以通过精细的流规则来匹配特定类型的数据包，并执行相应的动作（如转发、丢弃、重定向等）。
  可以实现复杂的流量分类和处理逻辑。
• 低延迟：
  流量控制通常在数据包进入网络设备时立即执行，可以实现低延迟的数据包处理。
  适用于对延迟敏感的应用场景。
• 硬件加速：
  流量控制可以利用硬件加速（如网卡的硬件过滤功能）来提高处理性能。
  可以减轻CPU的负担，提高整体系统性能。

---

优先级调度确保高优先级的事件优先被处理。

struct rte_event_queue_conf queue_conf = {
    .schedule_type = RTE_SCHED_TYPE_ATOMIC,
    .priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
};

// 配置高优先级队列
queue_conf.priority = RTE_EVENT_DEV_PRIORITY_HIGH;
rte_event_queue_setup(EVENT_DEV_ID, HIGH_PRIORITY_QUEUE_ID, &queue_conf);

// 配置低优先级队列
queue_conf.priority = RTE_EVENT_DEV_PRIORITY_NORMAL;
rte_event_queue_setup(EVENT_DEV_ID, NORMAL_PRIORITY_QUEUE_ID, &queue_conf);

轮询调度确保所有队列中的事件都能被公平处理。

struct rte_event_queue_conf queue_conf = {
    .schedule_type = RTE_SCHED_TYPE_PARALLEL,
    .priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
};

// 配置多个队列
for (uint16_t i = 0; i < NB_QUEUES; i++) {
    rte_event_queue_setup(EVENT_DEV_ID, i, &queue_conf);
}

多阶段处理将复杂的处理任务拆分为多个阶段，每个阶段由不同的事件队列和事件端口处理。

// 配置第一阶段队列
struct rte_event_queue_conf queue_conf_stage1 = {
    .schedule_type = RTE_SCHED_TYPE_ATOMIC,
    .priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
};
rte_event_queue_setup(EVENT_DEV_ID, STAGE1_QUEUE_ID, &queue_conf_stage1);

// 配置第二阶段队列
struct rte_event_queue_conf queue_conf_stage2 = {
    .schedule_type = RTE_SCHED_TYPE_ATOMIC,
    .priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
};
rte_event_queue_setup(EVENT_DEV_ID, STAGE2_QUEUE_ID, &queue_conf_stage2);

// 配置第三阶段队列
struct rte_event_queue_conf queue_conf_stage3 = {
    .schedule_type = RTE_SCHED_TYPE_ATOMIC,
    .priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
};
rte_event_queue_setup(EVENT_DEV_ID, STAGE3_QUEUE_ID, &queue_conf_stage3);

---

使用案例：

#include <rte_eal.h>
#include <rte_ethdev.h>
#include <rte_eventdev.h>
#include <rte_mbuf.h>
#include <stdio.h>

#define PORT_ID 0
#define EVENT_DEV_ID 0
#define NB_QUEUES 2
#define NB_EVENTS 1024

static int init_event_dev(void) {
    struct rte_event_dev_config event_dev_conf = {
        .dequeue_timeout_ns = 0,
        .nb_events_limit = NB_EVENTS,
        .nb_event_queues = NB_QUEUES,
        .nb_event_ports = rte_lcore_count(),
        .nb_event_queue_flows = 1024,
        .nb_event_port_dequeue_depth = 32,
        .nb_event_port_enqueue_depth = 32,
    };

    if (rte_event_dev_configure(EVENT_DEV_ID, &event_dev_conf) < 0) {
        rte_exit(EXIT_FAILURE, "Error configuring event device\n");
    }

    for (uint16_t i = 0; i < NB_QUEUES; i++) {
        struct rte_event_queue_conf queue_conf = {
            .schedule_type = RTE_SCHED_TYPE_ATOMIC,
            .priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
        };

        if (rte_event_queue_setup(EVENT_DEV_ID, i, &queue_conf) < 0) {
            rte_exit(EXIT_FAILURE, "Error setting up event queue\n");
        }
    }

    for (uint16_t i = 0; i < rte_lcore_count(); i++) {
        struct rte_event_port_conf port_conf = {
            .new_event_threshold = -1,
            .dequeue_depth = 32,
            .enqueue_depth = 32,
        };

        if (rte_event_port_setup(EVENT_DEV_ID, i, &port_conf) < 0) {
            rte_exit(EXIT_FAILURE, "Error setting up event port\n");
        }

        uint8_t queues[NB_QUEUES] = {0, 1};
        uint8_t priorities[NB_QUEUES] = {RTE_EVENT_DEV_PRIORITY_NORMAL, RTE_EVENT_DEV_PRIORITY_HIGH};

        if (rte_event_port_link(EVENT_DEV_ID, i, queues, priorities, NB_QUEUES) < 0) {
            rte_exit(EXIT_FAILURE, "Error linking event port\n");
        }
    }

    if (rte_event_dev_start(EVENT_DEV_ID) < 0) {
        rte_exit(EXIT_FAILURE, "Error starting event device\n");
    }

    return 0;
}

int main(int argc, char **argv) {
    // 初始化 DPDK 环境
    if (rte_eal_init(argc, argv) < 0)
        rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");

    // 初始化事件设备
    if (init_event_dev() < 0)
        rte_exit(EXIT_FAILURE, "Error initializing event device\n");

    // 主循环
    while (1) {
        struct rte_event ev;
        if (rte_event_dequeue_burst(EVENT_DEV_ID, 0, &ev, 1, 0) > 0) {
            printf("Processing event from queue %u\n", ev.queue_id);
            // 在此处理接收到的事件
        }
    }

    // 停止事件设备
    rte_event_dev_stop(EVENT_DEV_ID);

    // 关闭事件设备
    rte_event_dev_close(EVENT_DEV_ID);

    return 0;
}