Convert Figma logo to code with AI

DPDK logodpdk

Data Plane Development Kit

3,266
1,212
3,266
19

Top Related Projects

RDMA core userspace libraries and daemons

1,236

Mirror of VPP code base hosted at git.fd.io

2,669

High-speed packet processing framework

Quick Overview

DPDK (Data Plane Development Kit) is a set of libraries and drivers for fast packet processing in data plane applications. It is designed to run on any processor and provides a programming framework for high-performance network applications, including network function virtualization (NFV) and software-defined networking (SDN).

Pros

  • High performance: Optimized for fast packet processing and low latency
  • Cross-platform support: Works on various architectures and operating systems
  • Extensive documentation and community support
  • Rich set of libraries and tools for network application development

Cons

  • Steep learning curve for beginners
  • Requires specific hardware support for optimal performance
  • Can be complex to integrate with existing network stacks
  • Limited support for some network protocols compared to traditional stacks

Code Examples

  1. Initializing DPDK:
#include <rte_eal.h>

int main(int argc, char **argv)
{
    int ret = rte_eal_init(argc, argv);
    if (ret < 0)
        rte_exit(EXIT_FAILURE, "Error initializing EAL\n");
    
    // DPDK initialization successful
    return 0;
}
  1. Allocating a memory pool:
#include <rte_mempool.h>

#define POOL_SIZE 8192
#define CACHE_SIZE 256

struct rte_mempool *mbuf_pool;

mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL", POOL_SIZE,
    CACHE_SIZE, 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
if (mbuf_pool == NULL)
    rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n");
  1. Receiving packets:
#include <rte_ethdev.h>

#define BURST_SIZE 32

struct rte_mbuf *bufs[BURST_SIZE];
uint16_t nb_rx = rte_eth_rx_burst(port_id, 0, bufs, BURST_SIZE);

for (int i = 0; i < nb_rx; i++) {
    // Process received packets
    rte_pktmbuf_free(bufs[i]);
}

Getting Started

To get started with DPDK:

  1. Install dependencies:

    sudo apt-get install build-essential libnuma-dev
    
  2. Clone the DPDK repository:

    git clone https://github.com/DPDK/dpdk.git
    cd dpdk
    
  3. Build DPDK:

    meson build
    cd build
    ninja
    sudo ninja install
    
  4. Set up hugepages:

    sudo mkdir -p /mnt/huge
    sudo mount -t hugetlbfs nodev /mnt/huge
    echo 1024 | sudo tee /sys/devices/system/node/node0/hugepages/hugepages-2048kB/nr_hugepages
    
  5. Load required kernel modules:

    sudo modprobe uio
    sudo insmod /lib/modules/$(uname -r)/kernel/drivers/uio/igb_uio.ko
    

Now you're ready to start developing with DPDK!

Competitor Comparisons

RDMA core userspace libraries and daemons

Pros of rdma-core

  • Focused specifically on RDMA (Remote Direct Memory Access) technology
  • Tighter integration with the Linux kernel
  • Smaller codebase, potentially easier to maintain and contribute to

Cons of rdma-core

  • Limited to RDMA functionality, less versatile than DPDK
  • Smaller community and ecosystem compared to DPDK
  • May have fewer optimization options for non-RDMA use cases

Code Comparison

rdma-core example (using libibverbs):

struct ibv_device **dev_list;
int num_devices;
dev_list = ibv_get_device_list(&num_devices);
struct ibv_context *context = ibv_open_device(dev_list[0]);

DPDK example:

int ret = rte_eal_init(argc, argv);
unsigned nb_ports = rte_eth_dev_count_avail();
struct rte_mempool *mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL", 8191, 0, 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());

Both libraries provide low-level networking capabilities, but DPDK offers a broader range of features for packet processing and network function virtualization, while rdma-core specializes in RDMA operations. DPDK's larger community and extensive documentation may make it easier for beginners, but rdma-core's focused approach could be advantageous for specific RDMA-centric projects.

1,236

Mirror of VPP code base hosted at git.fd.io

Pros of VPP

  • Higher-level networking stack with built-in routing, switching, and VPN capabilities
  • Modular plugin architecture for easy extensibility
  • Graph-based packet processing for efficient pipeline execution

Cons of VPP

  • Steeper learning curve due to more complex architecture
  • Less flexible for non-networking use cases
  • Smaller community and ecosystem compared to DPDK

Code Comparison

VPP (graph node implementation):

VLIB_NODE_FN (ip4_lookup_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
                                vlib_frame_t * frame)
{
  return ip4_lookup_inline (vm, node, frame);
}

DPDK (packet processing loop):

static int lcore_main(__rte_unused void *arg)
{
    struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
    unsigned lcore_id = rte_lcore_id();
    unsigned i, j, portid, nb_rx;

    RTE_ETH_FOREACH_DEV(portid) {
        /* ... Process packets ... */
    }
    return 0;
}

VPP provides a higher-level abstraction for packet processing using a graph-based approach, while DPDK offers lower-level control over packet handling. VPP's architecture is more suitable for complex networking applications, whereas DPDK provides greater flexibility for custom packet processing implementations.

2,669

High-speed packet processing framework

Pros of PF_RING

  • Easier to set up and use, with a simpler API
  • Better compatibility with standard network drivers
  • Lower CPU usage for packet capture in some scenarios

Cons of PF_RING

  • Limited hardware offload capabilities compared to DPDK
  • Less flexibility for custom packet processing pipelines
  • Smaller ecosystem and community support

Code Comparison

PF_RING example:

#include <pfring.h>

pfring *ring = pfring_open("eth0", 1500, PF_RING_PROMISC);
pfring_enable_ring(ring);
pfring_recv(ring, &buffer, sizeof(buffer), &hdr, 0);

DPDK example:

#include <rte_eal.h>
#include <rte_ethdev.h>

rte_eal_init(argc, argv);
rte_eth_rx_burst(port_id, 0, &rx_bufs[0], MAX_PKT_BURST);
rte_pktmbuf_free(rx_bufs[i]);

Both PF_RING and DPDK are high-performance packet processing frameworks, but they have different strengths. PF_RING is more user-friendly and easier to integrate with existing systems, while DPDK offers superior performance and hardware offload capabilities at the cost of increased complexity and setup requirements.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

DPDK is a set of libraries and drivers for fast packet processing. It supports many processor architectures and both FreeBSD and Linux.

The DPDK uses the Open Source BSD-3-Clause license for the core libraries and drivers. The kernel components are GPL-2.0 licensed.

Please check the doc directory for release notes, API documentation, and sample application information.

For questions and usage discussions, subscribe to: users@dpdk.org Report bugs and issues to the development mailing list: dev@dpdk.org