以下是一个简单的DPDK程序示例，用于在一个核心上运行定时任务，并在其他核心上抓取数据包：

#include <rte_eal.h>
#include <rte_common.h>
#include <rte_lcore.h>
#include <rte_mbuf.h>

#define RX_QUEUE_PER_LCORE 16

static volatile bool force_quit;

// 定义定时器回调函数
static void timer_callback(__attribute__((unused)) struct rte_timer *timer, __attribute__((unused)) void *arg)
{
    // 在这里可以执行一些定期任务，例如检查状态、更新统计信息等
    printf("Timer callback executed.\n");
}

// 定义处理数据包的函数
static void packet_handler(uint16_t port_id, uint16_t queue_id)
{
    struct rte_mbuf *bufs[32];
    const uint16_t nb_rx = rte_eth_rx_burst(port_id, queue_id, bufs, 32);
    
    if (nb_rx == 0) {
        return;
    }
    
    // 在这里可以对接收到的数据包进行处理，例如解析协议、提取关键信息等
    printf("Received %d packets on port %u, queue %u.\n", nb_rx, port_id, queue_id);
    
    for (uint16_t i = 0; i < nb_rx; i++) {
        rte_pktmbuf_free(bufs[i]);
    }
}

// DPDK主循环
static int main_loop(__attribute__((unused)) void *arg)
{
    // 获取当前线程所绑定的CPU核心编号
    const uint32_t lcore_id = rte_lcore_id();
    
    // 设置定时器
    struct rte_timer timer;
    rte_timer_init(&timer);
    rte_timer_reset(&timer, 1000000, PERIODICAL, lcore_id, timer_callback, NULL);
    
    // 循环处理数据包
    while (!force_quit) {
        for (uint16_t i = 0; i < RX_QUEUE_PER_LCORE; i++) {
            packet_handler(0, i);
        }
    }
    
    return 0;
}

int main(int argc, char *argv[])
{
    // 初始化DPDK环境
    int ret = rte_eal_init(argc, argv);
    
    if (ret < 0) {
        rte_exit(EXIT_FAILURE, "Cannot init EAL.\n");
    }
    
    argc -= ret;
    argv += ret;
    
    // 获取网卡数量
    const uint16_t nb_ports = rte_eth_dev_count_avail();
    
    if (nb_ports == 0) {
        rte_exit(EXIT_FAILURE, "No Ethernet ports detected.\n");
    }
    
    // 配置每个核心的网络接收队列和对应的网卡端口
    uint32_t port_id = 0;
    
    RTE_LCORE_FOREACH_SLAVE(uint32_t, lcore_id) {
        for (uint16_t queue_id = 0; queue_id < RX_QUEUE_PER_LCORE; queue_id++) {
            const uint16_t socket_id = rte_lcore_to_socket_id(lcore_id);
            
            struct rte_eth_conf port_conf;
            memset(&port_conf, 0, sizeof(port_conf));
            port_conf.rxmode.max_rx_pkt_len = ETHER_MAX_LEN;
            port_conf.rxmode.mq_mode = ETH_MQ_RX_RSS;
            port_conf.rx_adv_conf.rss_conf.rss_key = NULL;
            port_conf.rx_adv_conf.rss_conf.rss_hf = ETH_RSS_IP;
            
            if (rte_eth_dev_configure(port_id, 1, 1, &port_conf) != 0) {
                rte_exit(EXIT_FAILURE, "Cannot configure port %u.\n", port_id);
            }
            
            const uint16_t nb_rx_queues = 1;
            
            if (rte_eth_rx_queue_setup(port_id, queue_id, 128, socket_id, NULL, rte_pktmbuf_pool_create("MBUF_POOL", 8192 * nb_ports,
                                         250, RTE_ALIGN(64, sizeof(struct rte_mbuf)), socket_id)) < 0) {
                rte_exit(EXIT_FAILURE, "Cannot setup RX queue for port %u and queue %u.\n", port_id, queue_id);
            }
            
            if (rte_eth_dev_start(port_id) < 0) {
                rte_exit(EXIT_FAILURE, "Cannot start port %u.\n", port_id);
            }
        }
    }
    
    // 启动主循环
    force_quit = false;
    ret = rte_eal_mp_remote_launch(main_loop, NULL, SKIP_MASTER);
    
    // 等待所有线程退出
    if (ret < 0) {
        return -1;
    } else {
        RTE_LCORE_FOREACH_SLAVE(uint32_t, lcore_id) {
            if (rte_eal_wait_lcore(lcore_id) < 0) {
                return -1;
            }
        }
    }

    return EXIT_SUCCESS;
}

在此示例中，我们使用单个核心运行定时任务，并在其他核心上抓取和处理数据包。请注意，这只是一个简单的示例程序，您需要根据实际情况进行修改和优化。