rte_eventdev.h

Go to the documentation of this file.

/*
 *   BSD LICENSE
 *
 *   Copyright 2016 Cavium, Inc.
 *   Copyright 2016 Intel Corporation.
 *   Copyright 2016 NXP.
 *
 *   Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following conditions
 *   are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *     * Neither the name of Cavium, Inc nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _RTE_EVENTDEV_H_
#define _RTE_EVENTDEV_H_

#ifdef __cplusplus
extern "C" {
#endif

#include <rte_common.h>
#include <rte_memory.h>
#include <rte_errno.h>

struct rte_mbuf; /* we just use mbuf pointers; no need to include rte_mbuf.h */

/* Event device capability bitmap flags */
#define RTE_EVENT_DEV_CAP_QUEUE_QOS           (1ULL << 0)

#define RTE_EVENT_DEV_CAP_EVENT_QOS           (1ULL << 1)

#define RTE_EVENT_DEV_CAP_DISTRIBUTED_SCHED   (1ULL << 2)

#define RTE_EVENT_DEV_CAP_QUEUE_ALL_TYPES     (1ULL << 3)

#define RTE_EVENT_DEV_CAP_BURST_MODE          (1ULL << 4)

/* Event device priority levels */
#define RTE_EVENT_DEV_PRIORITY_HIGHEST   0

#define RTE_EVENT_DEV_PRIORITY_NORMAL    128

#define RTE_EVENT_DEV_PRIORITY_LOWEST    255

uint8_t
rte_event_dev_count(void);

int
rte_event_dev_get_dev_id(const char *name);

int
rte_event_dev_socket_id(uint8_t dev_id);

struct rte_event_dev_info {
        const char *driver_name;        
        struct rte_device *dev; 
        uint32_t min_dequeue_timeout_ns;
        uint32_t max_dequeue_timeout_ns;
        uint32_t dequeue_timeout_ns;
        uint8_t max_event_queues;
        uint32_t max_event_queue_flows;
        uint8_t max_event_queue_priority_levels;
        uint8_t max_event_priority_levels;
        uint8_t max_event_ports;
        uint8_t max_event_port_dequeue_depth;
        uint32_t max_event_port_enqueue_depth;
        int32_t max_num_events;
        uint32_t event_dev_cap;
};

int
rte_event_dev_info_get(uint8_t dev_id, struct rte_event_dev_info *dev_info);

/* Event device configuration bitmap flags */
#define RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT (1ULL << 0)

struct rte_event_dev_config {
        uint32_t dequeue_timeout_ns;
        int32_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;
        uint32_t event_dev_cfg;
};

int
rte_event_dev_configure(uint8_t dev_id,
                        const struct rte_event_dev_config *dev_conf);


/* Event queue specific APIs */

/* Event queue configuration bitmap flags */
#define RTE_EVENT_QUEUE_CFG_TYPE_MASK          (3ULL << 0)

#define RTE_EVENT_QUEUE_CFG_ALL_TYPES          (0ULL << 0)

#define RTE_EVENT_QUEUE_CFG_ATOMIC_ONLY        (1ULL << 0)

#define RTE_EVENT_QUEUE_CFG_ORDERED_ONLY       (2ULL << 0)

#define RTE_EVENT_QUEUE_CFG_PARALLEL_ONLY      (3ULL << 0)

#define RTE_EVENT_QUEUE_CFG_SINGLE_LINK        (1ULL << 2)

struct rte_event_queue_conf {
        uint32_t nb_atomic_flows;
        uint32_t nb_atomic_order_sequences;
        uint32_t event_queue_cfg; 
        uint8_t priority;
};

int
rte_event_queue_default_conf_get(uint8_t dev_id, uint8_t queue_id,
                                 struct rte_event_queue_conf *queue_conf);

int
rte_event_queue_setup(uint8_t dev_id, uint8_t queue_id,
                      const struct rte_event_queue_conf *queue_conf);

uint8_t
rte_event_queue_count(uint8_t dev_id);

uint8_t
rte_event_queue_priority(uint8_t dev_id, uint8_t queue_id);

/* Event port specific APIs */

struct rte_event_port_conf {
        int32_t new_event_threshold;
        uint16_t dequeue_depth;
        uint16_t enqueue_depth;
};

int
rte_event_port_default_conf_get(uint8_t dev_id, uint8_t port_id,
                                struct rte_event_port_conf *port_conf);

int
rte_event_port_setup(uint8_t dev_id, uint8_t port_id,
                     const struct rte_event_port_conf *port_conf);

uint8_t
rte_event_port_dequeue_depth(uint8_t dev_id, uint8_t port_id);

uint8_t
rte_event_port_enqueue_depth(uint8_t dev_id, uint8_t port_id);

uint8_t
rte_event_port_count(uint8_t dev_id);

int
rte_event_dev_start(uint8_t dev_id);

void
rte_event_dev_stop(uint8_t dev_id);

int
rte_event_dev_close(uint8_t dev_id);

/* Scheduler type definitions */
#define RTE_SCHED_TYPE_ORDERED          0

#define RTE_SCHED_TYPE_ATOMIC           1

#define RTE_SCHED_TYPE_PARALLEL         2

/* Event types to classify the event source */
#define RTE_EVENT_TYPE_ETHDEV           0x0

#define RTE_EVENT_TYPE_CRYPTODEV        0x1

#define RTE_EVENT_TYPE_TIMERDEV         0x2

#define RTE_EVENT_TYPE_CPU              0x3

#define RTE_EVENT_TYPE_MAX              0x10

/* Event enqueue operations */
#define RTE_EVENT_OP_NEW                0

#define RTE_EVENT_OP_FORWARD            1

#define RTE_EVENT_OP_RELEASE            2

RTE_STD_C11
struct rte_event {
        union {
                uint64_t event;
                struct {
                        uint32_t flow_id:20;
                        uint32_t sub_event_type:8;
                        uint32_t event_type:4;
                        uint8_t op:2;
                        uint8_t rsvd:4;
                        uint8_t sched_type:2;
                        uint8_t queue_id;
                        uint8_t priority;
                        uint8_t impl_opaque;
                };
        };
        union {
                uint64_t u64;
                void *event_ptr;
                struct rte_mbuf *mbuf;
        };
};


struct rte_eventdev_driver;
struct rte_eventdev_ops;
struct rte_eventdev;

typedef void (*event_schedule_t)(struct rte_eventdev *dev);
typedef uint16_t (*event_enqueue_t)(void *port, const struct rte_event *ev);
typedef uint16_t (*event_enqueue_burst_t)(void *port,
                        const struct rte_event ev[], uint16_t nb_events);
typedef uint16_t (*event_dequeue_t)(void *port, struct rte_event *ev,
                uint64_t timeout_ticks);
typedef uint16_t (*event_dequeue_burst_t)(void *port, struct rte_event ev[],
                uint16_t nb_events, uint64_t timeout_ticks);
#define RTE_EVENTDEV_NAME_MAX_LEN       (64)

struct rte_eventdev_data {
        int socket_id;
        uint8_t dev_id;
        uint8_t nb_queues;
        uint8_t nb_ports;
        void **ports;
        uint8_t *ports_dequeue_depth;
        uint8_t *ports_enqueue_depth;
        uint8_t *queues_prio;
        uint16_t *links_map;
        void *dev_private;
        uint32_t event_dev_cap;
        struct rte_event_dev_config dev_conf;
        RTE_STD_C11
        uint8_t dev_started : 1;
        char name[RTE_EVENTDEV_NAME_MAX_LEN];
} __rte_cache_aligned;

struct rte_eventdev {
        event_schedule_t schedule;
        event_enqueue_t enqueue;
        event_enqueue_burst_t enqueue_burst;
        event_enqueue_burst_t enqueue_new_burst;
        event_enqueue_burst_t enqueue_forward_burst;
        event_dequeue_t dequeue;
        event_dequeue_burst_t dequeue_burst;
        struct rte_eventdev_data *data;
        const struct rte_eventdev_ops *dev_ops;
        struct rte_device *dev;
        RTE_STD_C11
        uint8_t attached : 1;
} __rte_cache_aligned;

extern struct rte_eventdev *rte_eventdevs;
static inline void
rte_event_schedule(uint8_t dev_id)
{
        struct rte_eventdev *dev = &rte_eventdevs[dev_id];
        if (*dev->schedule)
                (*dev->schedule)(dev);
}

static __rte_always_inline uint16_t
__rte_event_enqueue_burst(uint8_t dev_id, uint8_t port_id,
                        const struct rte_event ev[], uint16_t nb_events,
                        const event_enqueue_burst_t fn)
{
        const struct rte_eventdev *dev = &rte_eventdevs[dev_id];

#ifdef RTE_LIBRTE_EVENTDEV_DEBUG
        if (dev_id >= RTE_EVENT_MAX_DEVS || !rte_eventdevs[dev_id].attached) {
                rte_errno = -EINVAL;
                return 0;
        }

        if (port_id >= dev->data->nb_ports) {
                rte_errno = -EINVAL;
                return 0;
        }
#endif
        /*
         * Allow zero cost non burst mode routine invocation if application
         * requests nb_events as const one
         */
        if (nb_events == 1)
                return (*dev->enqueue)(dev->data->ports[port_id], ev);
        else
                return fn(dev->data->ports[port_id], ev, nb_events);
}

static inline uint16_t
rte_event_enqueue_burst(uint8_t dev_id, uint8_t port_id,
                        const struct rte_event ev[], uint16_t nb_events)
{
        const struct rte_eventdev *dev = &rte_eventdevs[dev_id];

        return __rte_event_enqueue_burst(dev_id, port_id, ev, nb_events,
                        dev->enqueue_burst);
}

static inline uint16_t
rte_event_enqueue_new_burst(uint8_t dev_id, uint8_t port_id,
                        const struct rte_event ev[], uint16_t nb_events)
{
        const struct rte_eventdev *dev = &rte_eventdevs[dev_id];

        return __rte_event_enqueue_burst(dev_id, port_id, ev, nb_events,
                        dev->enqueue_new_burst);
}

static inline uint16_t
rte_event_enqueue_forward_burst(uint8_t dev_id, uint8_t port_id,
                        const struct rte_event ev[], uint16_t nb_events)
{
        const struct rte_eventdev *dev = &rte_eventdevs[dev_id];

        return __rte_event_enqueue_burst(dev_id, port_id, ev, nb_events,
                        dev->enqueue_forward_burst);
}

int
rte_event_dequeue_timeout_ticks(uint8_t dev_id, uint64_t ns,
                                        uint64_t *timeout_ticks);

static inline uint16_t
rte_event_dequeue_burst(uint8_t dev_id, uint8_t port_id, struct rte_event ev[],
                        uint16_t nb_events, uint64_t timeout_ticks)
{
        struct rte_eventdev *dev = &rte_eventdevs[dev_id];

#ifdef RTE_LIBRTE_EVENTDEV_DEBUG
        if (dev_id >= RTE_EVENT_MAX_DEVS || !rte_eventdevs[dev_id].attached) {
                rte_errno = -EINVAL;
                return 0;
        }

        if (port_id >= dev->data->nb_ports) {
                rte_errno = -EINVAL;
                return 0;
        }
#endif

        /*
         * Allow zero cost non burst mode routine invocation if application
         * requests nb_events as const one
         */
        if (nb_events == 1)
                return (*dev->dequeue)(
                        dev->data->ports[port_id], ev, timeout_ticks);
        else
                return (*dev->dequeue_burst)(
                        dev->data->ports[port_id], ev, nb_events,
                                timeout_ticks);
}

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);

int
rte_event_port_unlink(uint8_t dev_id, uint8_t port_id,
                      uint8_t queues[], uint16_t nb_unlinks);

int
rte_event_port_links_get(uint8_t dev_id, uint8_t port_id,
                         uint8_t queues[], uint8_t priorities[]);

int
rte_event_dev_dump(uint8_t dev_id, FILE *f);

#define RTE_EVENT_DEV_XSTATS_NAME_SIZE 64

enum rte_event_dev_xstats_mode {
        RTE_EVENT_DEV_XSTATS_DEVICE,
        RTE_EVENT_DEV_XSTATS_PORT,
        RTE_EVENT_DEV_XSTATS_QUEUE,
};

struct rte_event_dev_xstats_name {
        char name[RTE_EVENT_DEV_XSTATS_NAME_SIZE];
};

int
rte_event_dev_xstats_names_get(uint8_t dev_id,
                               enum rte_event_dev_xstats_mode mode,
                               uint8_t queue_port_id,
                               struct rte_event_dev_xstats_name *xstats_names,
                               unsigned int *ids,
                               unsigned int size);

int
rte_event_dev_xstats_get(uint8_t dev_id,
                         enum rte_event_dev_xstats_mode mode,
                         uint8_t queue_port_id,
                         const unsigned int ids[],
                         uint64_t values[], unsigned int n);

uint64_t
rte_event_dev_xstats_by_name_get(uint8_t dev_id, const char *name,
                                 unsigned int *id);

int
rte_event_dev_xstats_reset(uint8_t dev_id,
                           enum rte_event_dev_xstats_mode mode,
                           int16_t queue_port_id,
                           const uint32_t ids[],
                           uint32_t nb_ids);

#ifdef __cplusplus
}
#endif

#endif /* _RTE_EVENTDEV_H_ */