d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

eventdev: add timer adapter common code

Browse Source 
This commit adds the logic that is shared by all event timer adapter
drivers; the common code handles instance allocation and some
initialization.

Signed-off-by: Erik Gabriel Carrillo <erik.g.carrillo@intel.com>
Acked-by: Pavan Nikhilesh <pbhagavatula@caviumnetworks.com>
This commit is contained in:
Erik Gabriel Carrillo 2018-04-04 16:51:08 -05:00 committed by Thomas Monjalon
parent 4e8eed7e1f
commit 47d05b2928
11 changed files with 623 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
config/common_base
View File

@ -558,6 +558,7 @@ CONFIG_RTE_LIBRTE_EVENTDEV=y
CONFIG_RTE_LIBRTE_EVENTDEV_DEBUG=n
CONFIG_RTE_EVENT_MAX_DEVS=16
CONFIG_RTE_EVENT_MAX_QUEUES_PER_DEV=64
CONFIG_RTE_EVENT_TIMER_ADAPTER_NUM_MAX=32
#
# Compile PMD for skeleton event device

1
config/rte_config.h
View File

@ -59,6 +59,7 @@
/* eventdev defines */
#define RTE_EVENT_MAX_DEVS 16
#define RTE_EVENT_MAX_QUEUES_PER_DEV 64
#define RTE_EVENT_TIMER_ADAPTER_NUM_MAX 32
/* ip_fragmentation defines */
#define RTE_LIBRTE_IP_FRAG_MAX_FRAG 4

18
drivers/event/sw/sw_evdev.c
View File

@ -464,6 +464,22 @@ sw_eth_rx_adapter_caps_get(const struct rte_eventdev *dev,
return 0;
}
static int
sw_timer_adapter_caps_get(const struct rte_eventdev *dev,
uint64_t flags,
uint32_t *caps,
const struct rte_event_timer_adapter_ops **ops)
{
RTE_SET_USED(dev);
RTE_SET_USED(flags);
*caps = 0;
/* Use default SW ops */
*ops = NULL;
return 0;
}
static void
sw_info_get(struct rte_eventdev *dev, struct rte_event_dev_info *info)
{
@ -791,6 +807,8 @@ sw_probe(struct rte_vdev_device *vdev)
.eth_rx_adapter_caps_get = sw_eth_rx_adapter_caps_get,
.timer_adapter_caps_get = sw_timer_adapter_caps_get,
.xstats_get = sw_xstats_get,
.xstats_get_names = sw_xstats_get_names,
.xstats_get_by_name = sw_xstats_get_by_name,

2
lib/librte_eventdev/Makefile
View File

@ -20,6 +20,7 @@ LDLIBS += -lrte_eal -lrte_ring -lrte_ethdev -lrte_hash
SRCS-y += rte_eventdev.c
SRCS-y += rte_event_ring.c
SRCS-y += rte_event_eth_rx_adapter.c
SRCS-y += rte_event_timer_adapter.c
# export include files
SYMLINK-y-include += rte_eventdev.h
@ -29,6 +30,7 @@ SYMLINK-y-include += rte_eventdev_pmd_vdev.h
SYMLINK-y-include += rte_event_ring.h
SYMLINK-y-include += rte_event_eth_rx_adapter.h
SYMLINK-y-include += rte_event_timer_adapter.h
SYMLINK-y-include += rte_event_timer_adapter_pmd.h
# versioning export map
EXPORT_MAP := rte_eventdev_version.map

6
lib/librte_eventdev/meson.build
View File

@ -5,12 +5,14 @@ version = 3
allow_experimental_apis = true
sources = files('rte_eventdev.c',
'rte_event_ring.c',
'rte_event_eth_rx_adapter.c')
'rte_event_eth_rx_adapter.c',
'rte_event_timer_adapter.c')
headers = files('rte_eventdev.h',
'rte_eventdev_pmd.h',
'rte_eventdev_pmd_pci.h',
'rte_eventdev_pmd_vdev.h',
'rte_event_ring.h',
'rte_event_eth_rx_adapter.h',
'rte_event_timer_adapter.h')
'rte_event_timer_adapter.h',
'rte_event_timer_adapter_pmd.h')
deps += ['ring', 'ethdev', 'hash']

387
lib/librte_eventdev/rte_event_timer_adapter.c Normal file
View File

@ -0,0 +1,387 @@
/* SPDX-License-Identifier: BSD-3-Clause
* Copyright(c) 2017-2018 Intel Corporation.
* All rights reserved.
*/
#include <string.h>
#include <inttypes.h>
#include <rte_memzone.h>
#include <rte_memory.h>
#include <rte_dev.h>
#include <rte_errno.h>
#include "rte_eventdev.h"
#include "rte_eventdev_pmd.h"
#include "rte_event_timer_adapter.h"
#include "rte_event_timer_adapter_pmd.h"
#define DATA_MZ_NAME_MAX_LEN 64
#define DATA_MZ_NAME_FORMAT "rte_event_timer_adapter_data_%d"
static int evtim_logtype;
static struct rte_event_timer_adapter adapters[RTE_EVENT_TIMER_ADAPTER_NUM_MAX];
#define EVTIM_LOG(level, logtype, ...) \
rte_log(RTE_LOG_ ## level, logtype, \
RTE_FMT("EVTIMER: %s() line %u: " RTE_FMT_HEAD(__VA_ARGS__,) \
"\n", __func__, __LINE__, RTE_FMT_TAIL(__VA_ARGS__,)))
#define EVTIM_LOG_ERR(...) EVTIM_LOG(ERR, evtim_logtype, __VA_ARGS__)
#ifdef RTE_LIBRTE_EVENTDEV_DEBUG
#define EVTIM_LOG_DBG(...) \
EVTIM_LOG(DEBUG, evtim_logtype, __VA_ARGS__)
#else
#define EVTIM_LOG_DBG(...) (void)0
#endif
static int
default_port_conf_cb(uint16_t id, uint8_t event_dev_id, uint8_t *event_port_id,
void *conf_arg)
{
struct rte_event_timer_adapter *adapter;
struct rte_eventdev *dev;
struct rte_event_dev_config dev_conf;
struct rte_event_port_conf *port_conf, def_port_conf = {0};
int started;
uint8_t port_id;
uint8_t dev_id;
int ret;
RTE_SET_USED(event_dev_id);
adapter = &adapters[id];
dev = &rte_eventdevs[adapter->data->event_dev_id];
dev_id = dev->data->dev_id;
dev_conf = dev->data->dev_conf;
started = dev->data->dev_started;
if (started)
rte_event_dev_stop(dev_id);
port_id = dev_conf.nb_event_ports;
dev_conf.nb_event_ports += 1;
ret = rte_event_dev_configure(dev_id, &dev_conf);
if (ret < 0) {
EVTIM_LOG_ERR("failed to configure event dev %u\n", dev_id);
if (started)
if (rte_event_dev_start(dev_id))
return -EIO;
return ret;
}
if (conf_arg != NULL)
port_conf = conf_arg;
else {
port_conf = &def_port_conf;
ret = rte_event_port_default_conf_get(dev_id, port_id,
port_conf);
if (ret < 0)
return ret;
}
ret = rte_event_port_setup(dev_id, port_id, port_conf);
if (ret < 0) {
EVTIM_LOG_ERR("failed to setup event port %u on event dev %u\n",
port_id, dev_id);
return ret;
}
*event_port_id = port_id;
if (started)
ret = rte_event_dev_start(dev_id);
return ret;
}
struct rte_event_timer_adapter * __rte_experimental
rte_event_timer_adapter_create(const struct rte_event_timer_adapter_conf *conf)
{
return rte_event_timer_adapter_create_ext(conf, default_port_conf_cb,
NULL);
}
struct rte_event_timer_adapter * __rte_experimental
rte_event_timer_adapter_create_ext(
const struct rte_event_timer_adapter_conf *conf,
rte_event_timer_adapter_port_conf_cb_t conf_cb,
void *conf_arg)
{
uint16_t adapter_id;
struct rte_event_timer_adapter *adapter;
const struct rte_memzone *mz;
char mz_name[DATA_MZ_NAME_MAX_LEN];
int n, ret;
struct rte_eventdev *dev;
if (conf == NULL) {
rte_errno = EINVAL;
return NULL;
}
/* Check eventdev ID */
if (!rte_event_pmd_is_valid_dev(conf->event_dev_id)) {
rte_errno = EINVAL;
return NULL;
}
dev = &rte_eventdevs[conf->event_dev_id];
adapter_id = conf->timer_adapter_id;
/* Check that adapter_id is in range */
if (adapter_id >= RTE_EVENT_TIMER_ADAPTER_NUM_MAX) {
rte_errno = EINVAL;
return NULL;
}
/* Check adapter ID not already allocated */
adapter = &adapters[adapter_id];
if (adapter->allocated) {
rte_errno = EEXIST;
return NULL;
}
/* Create shared data area. */
n = snprintf(mz_name, sizeof(mz_name), DATA_MZ_NAME_FORMAT, adapter_id);
if (n >= (int)sizeof(mz_name)) {
rte_errno = EINVAL;
return NULL;
}
mz = rte_memzone_reserve(mz_name,
sizeof(struct rte_event_timer_adapter_data),
conf->socket_id, 0);
if (mz == NULL)
/* rte_errno set by rte_memzone_reserve */
return NULL;
adapter->data = mz->addr;
memset(adapter->data, 0, sizeof(struct rte_event_timer_adapter_data));
adapter->data->mz = mz;
adapter->data->event_dev_id = conf->event_dev_id;
adapter->data->id = adapter_id;
adapter->data->socket_id = conf->socket_id;
adapter->data->conf = *conf; /* copy conf structure */
/* Query eventdev PMD for timer adapter capabilities and ops */
ret = dev->dev_ops->timer_adapter_caps_get(dev,
adapter->data->conf.flags,
&adapter->data->caps,
&adapter->ops);
if (ret < 0) {
rte_errno = ret;
goto free_memzone;
}
if (!(adapter->data->caps &
RTE_EVENT_TIMER_ADAPTER_CAP_INTERNAL_PORT)) {
FUNC_PTR_OR_NULL_RET_WITH_ERRNO(conf_cb, -EINVAL);
ret = conf_cb(adapter->data->id, adapter->data->event_dev_id,
&adapter->data->event_port_id, conf_arg);
if (ret < 0) {
rte_errno = ret;
goto free_memzone;
}
}
/* Allow driver to do some setup */
FUNC_PTR_OR_NULL_RET_WITH_ERRNO(adapter->ops->init, -ENOTSUP);
ret = adapter->ops->init(adapter);
if (ret < 0) {
rte_errno = ret;
goto free_memzone;
}
/* Set fast-path function pointers */
adapter->arm_burst = adapter->ops->arm_burst;
adapter->arm_tmo_tick_burst = adapter->ops->arm_tmo_tick_burst;
adapter->cancel_burst = adapter->ops->cancel_burst;
adapter->allocated = 1;
return adapter;
free_memzone:
rte_memzone_free(adapter->data->mz);
return NULL;
}
int __rte_experimental
rte_event_timer_adapter_get_info(const struct rte_event_timer_adapter *adapter,
struct rte_event_timer_adapter_info *adapter_info)
{
ADAPTER_VALID_OR_ERR_RET(adapter, -EINVAL);
if (adapter->ops->get_info)
/* let driver set values it knows */
adapter->ops->get_info(adapter, adapter_info);
/* Set common values */
adapter_info->conf = adapter->data->conf;
adapter_info->event_dev_port_id = adapter->data->event_port_id;
adapter_info->caps = adapter->data->caps;
return 0;
}
int __rte_experimental
rte_event_timer_adapter_start(const struct rte_event_timer_adapter *adapter)
{
int ret;
ADAPTER_VALID_OR_ERR_RET(adapter, -EINVAL);
FUNC_PTR_OR_ERR_RET(adapter->ops->start, -EINVAL);
ret = adapter->ops->start(adapter);
if (ret < 0)
return ret;
adapter->data->started = 1;
return 0;
}
int __rte_experimental
rte_event_timer_adapter_stop(const struct rte_event_timer_adapter *adapter)
{
int ret;
ADAPTER_VALID_OR_ERR_RET(adapter, -EINVAL);
FUNC_PTR_OR_ERR_RET(adapter->ops->stop, -EINVAL);
if (adapter->data->started == 0) {
EVTIM_LOG_ERR("event timer adapter %"PRIu8" already stopped",
adapter->data->id);
return 0;
}
ret = adapter->ops->stop(adapter);
if (ret < 0)
return ret;
adapter->data->started = 0;
return 0;
}
struct rte_event_timer_adapter * __rte_experimental
rte_event_timer_adapter_lookup(uint16_t adapter_id)
{
char name[DATA_MZ_NAME_MAX_LEN];
const struct rte_memzone *mz;
struct rte_event_timer_adapter_data *data;
struct rte_event_timer_adapter *adapter;
int ret;
struct rte_eventdev *dev;
if (adapters[adapter_id].allocated)
return &adapters[adapter_id]; /* Adapter is already loaded */
snprintf(name, DATA_MZ_NAME_MAX_LEN, DATA_MZ_NAME_FORMAT, adapter_id);
mz = rte_memzone_lookup(name);
if (mz == NULL) {
rte_errno = ENOENT;
return NULL;
}
data = mz->addr;
adapter = &adapters[data->id];
adapter->data = data;
dev = &rte_eventdevs[adapter->data->event_dev_id];
/* Query eventdev PMD for timer adapter capabilities and ops */
ret = dev->dev_ops->timer_adapter_caps_get(dev,
adapter->data->conf.flags,
&adapter->data->caps,
&adapter->ops);
if (ret < 0) {
rte_errno = EINVAL;
return NULL;
}
/* Set fast-path function pointers */
adapter->arm_burst = adapter->ops->arm_burst;
adapter->arm_tmo_tick_burst = adapter->ops->arm_tmo_tick_burst;
adapter->cancel_burst = adapter->ops->cancel_burst;
adapter->allocated = 1;
return adapter;
}
int __rte_experimental
rte_event_timer_adapter_free(struct rte_event_timer_adapter *adapter)
{
int ret;
ADAPTER_VALID_OR_ERR_RET(adapter, -EINVAL);
FUNC_PTR_OR_ERR_RET(adapter->ops->uninit, -EINVAL);
if (adapter->data->started == 1) {
EVTIM_LOG_ERR("event timer adapter %"PRIu8" must be stopped "
"before freeing", adapter->data->id);
return -EBUSY;
}
/* free impl priv data */
ret = adapter->ops->uninit(adapter);
if (ret < 0)
return ret;
/* free shared data area */
ret = rte_memzone_free(adapter->data->mz);
if (ret < 0)
return ret;
adapter->data = NULL;
adapter->allocated = 0;
return 0;
}
int __rte_experimental
rte_event_timer_adapter_service_id_get(struct rte_event_timer_adapter *adapter,
uint32_t *service_id)
{
ADAPTER_VALID_OR_ERR_RET(adapter, -EINVAL);
if (adapter->data->service_inited && service_id != NULL)
*service_id = adapter->data->service_id;
return adapter->data->service_inited ? 0 : -ESRCH;
}
int __rte_experimental
rte_event_timer_adapter_stats_get(struct rte_event_timer_adapter *adapter,
struct rte_event_timer_adapter_stats *stats)
{
ADAPTER_VALID_OR_ERR_RET(adapter, -EINVAL);
FUNC_PTR_OR_ERR_RET(adapter->ops->stats_get, -EINVAL);
if (stats == NULL)
return -EINVAL;
return adapter->ops->stats_get(adapter, stats);
}
int __rte_experimental
rte_event_timer_adapter_stats_reset(struct rte_event_timer_adapter *adapter)
{
ADAPTER_VALID_OR_ERR_RET(adapter, -EINVAL);
FUNC_PTR_OR_ERR_RET(adapter->ops->stats_reset, -EINVAL);
return adapter->ops->stats_reset(adapter);
}
RTE_INIT(event_timer_adapter_init_log);
static void
event_timer_adapter_init_log(void)
{
evtim_logtype = rte_log_register("lib.eventdev.adapter.timer");
if (evtim_logtype >= 0)
rte_log_set_level(evtim_logtype, RTE_LOG_NOTICE);
}

114
lib/librte_eventdev/rte_event_timer_adapter_pmd.h Normal file
View File

@ -0,0 +1,114 @@
/* SPDX-License-Identifier: BSD-3-Clause
* Copyright(c) 2017-2018 Intel Corporation.
* All rights reserved.
*/
#ifndef __RTE_EVENT_TIMER_ADAPTER_PMD_H__
#define __RTE_EVENT_TIMER_ADAPTER_PMD_H__
/**
* @file
* RTE Event Timer Adapter API (PMD Side)
*
* @note
* This file provides implementation helpers for internal use by PMDs. They
* are not intended to be exposed to applications and are not subject to ABI
* versioning.
*
*/
#ifdef __cplusplus
extern "C" {
#endif
#include "rte_event_timer_adapter.h"
/*
* Definitions of functions exported by an event timer adapter implementation
* through *rte_event_timer_adapter_ops* structure supplied in the
* *rte_event_timer_adapter* structure associated with an event timer adapter.
*/
typedef int (*rte_event_timer_adapter_init_t)(
struct rte_event_timer_adapter *adapter);
/**< @internal Event timer adapter implementation setup */
typedef int (*rte_event_timer_adapter_uninit_t)(
struct rte_event_timer_adapter *adapter);
/**< @internal Event timer adapter implementation teardown */
typedef int (*rte_event_timer_adapter_start_t)(
const struct rte_event_timer_adapter *adapter);
/**< @internal Start running event timer adapter */
typedef int (*rte_event_timer_adapter_stop_t)(
const struct rte_event_timer_adapter *adapter);
/**< @internal Stop running event timer adapter */
typedef void (*rte_event_timer_adapter_get_info_t)(
const struct rte_event_timer_adapter *adapter,
struct rte_event_timer_adapter_info *adapter_info);
/**< @internal Get contextual information for event timer adapter */
typedef int (*rte_event_timer_adapter_stats_get_t)(
const struct rte_event_timer_adapter *adapter,
struct rte_event_timer_adapter_stats *stats);
/**< @internal Get statistics for event timer adapter */
typedef int (*rte_event_timer_adapter_stats_reset_t)(
const struct rte_event_timer_adapter *adapter);
/**< @internal Reset statistics for event timer adapter */
/**
* @internal Structure containing the functions exported by an event timer
* adapter implementation.
*/
struct rte_event_timer_adapter_ops {
rte_event_timer_adapter_init_t init; /**< Set up adapter */
rte_event_timer_adapter_uninit_t uninit;/**< Tear down adapter */
rte_event_timer_adapter_start_t start; /**< Start adapter */
rte_event_timer_adapter_stop_t stop; /**< Stop adapter */
rte_event_timer_adapter_get_info_t get_info;
/**< Get info from driver */
rte_event_timer_adapter_stats_get_t stats_get;
/**< Get adapter statistics */
rte_event_timer_adapter_stats_reset_t stats_reset;
/**< Reset adapter statistics */
rte_event_timer_arm_burst_t arm_burst;
/**< Arm one or more event timers */
rte_event_timer_arm_tmo_tick_burst_t arm_tmo_tick_burst;
/**< Arm event timers with same expiration time */
rte_event_timer_cancel_burst_t cancel_burst;
/**< Cancel one or more event timers */
};
/**
* @internal Adapter data; structure to be placed in shared memory to be
* accessible by various processes in a multi-process configuration.
*/
struct rte_event_timer_adapter_data {
uint8_t id;
/**< Event timer adapter ID */
uint8_t event_dev_id;
/**< Event device ID */
uint32_t socket_id;
/**< Socket ID where memory is allocated */
uint8_t event_port_id;
/**< Optional: event port ID used when the inbuilt port is absent */
const struct rte_memzone *mz;
/**< Event timer adapter memzone pointer */
struct rte_event_timer_adapter_conf conf;
/**< Configuration used to configure the adapter. */
uint32_t caps;
/**< Adapter capabilities */
void *adapter_priv;
/**< Timer adapter private data*/
uint8_t service_inited;
/**< Service initialization state */
uint32_t service_id;
/**< Service ID*/
RTE_STD_C11
uint8_t started : 1;
/**< Flag to indicate adapter started. */
} __rte_cache_aligned;
#ifdef __cplusplus
}
#endif
#endif /* __RTE_EVENT_TIMER_ADAPTER_PMD_H__ */

22
lib/librte_eventdev/rte_eventdev.c
View File

@ -123,6 +123,28 @@ rte_event_eth_rx_adapter_caps_get(uint8_t dev_id, uint8_t eth_port_id,
: 0;
}
int __rte_experimental
rte_event_timer_adapter_caps_get(uint8_t dev_id, uint32_t *caps)
{
struct rte_eventdev *dev;
const struct rte_event_timer_adapter_ops *ops;
RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
dev = &rte_eventdevs[dev_id];
if (caps == NULL)
return -EINVAL;
*caps = 0;
return dev->dev_ops->timer_adapter_caps_get ?
(*dev->dev_ops->timer_adapter_caps_get)(dev,
0,
caps,
&ops)
: 0;
}
static inline int
rte_event_dev_queue_config(struct rte_eventdev *dev, uint8_t nb_queues)
{

20
lib/librte_eventdev/rte_eventdev.h
View File

@ -215,6 +215,7 @@ extern "C" {
#include <rte_config.h>
#include <rte_memory.h>
#include <rte_errno.h>
#include <rte_compat.h>
struct rte_mbuf; /* we just use mbuf pointers; no need to include rte_mbuf.h */
struct rte_event;
@ -1115,6 +1116,25 @@ int
rte_event_eth_rx_adapter_caps_get(uint8_t dev_id, uint8_t eth_port_id,
uint32_t *caps);
#define RTE_EVENT_TIMER_ADAPTER_CAP_INTERNAL_PORT (1ULL << 0)
/**< This flag is set when the timer mechanism is in HW. */
/**
* Retrieve the event device's timer adapter capabilities.
*
* @param dev_id
* The identifier of the device.
*
* @param[out] caps
* A pointer to memory to be filled with event timer adapter capabilities.
*
* @return
* - 0: Success, driver provided event timer adapter capabilities.
* - <0: Error code returned by the driver function.
*/
int __rte_experimental
rte_event_timer_adapter_caps_get(uint8_t dev_id, uint32_t *caps);
struct rte_eventdev_driver;
struct rte_eventdev_ops;
struct rte_eventdev;

35
lib/librte_eventdev/rte_eventdev_pmd.h
View File

@ -26,6 +26,7 @@ extern "C" {
#include <rte_malloc.h>
#include "rte_eventdev.h"
#include "rte_event_timer_adapter_pmd.h"
/* Logging Macros */
#define RTE_EDEV_LOG_ERR(...) \
@ -448,6 +449,37 @@ typedef int (*eventdev_eth_rx_adapter_caps_get_t)
struct rte_event_eth_rx_adapter_queue_conf *queue_conf;
/**
* Retrieve the event device's timer adapter capabilities, as well as the ops
* structure that an event timer adapter should call through to enter the
* driver
*
* @param dev
* Event device pointer
*
* @param flags
* Flags that can be used to determine how to select an event timer
* adapter ops structure
*
* @param[out] caps
* A pointer to memory filled with Rx event adapter capabilities.
*
* @param[out] ops
* A pointer to the ops pointer to set with the address of the desired ops
* structure
*
* @return
* - 0: Success, driver provides Rx event adapter capabilities for the
* ethernet device.
* - <0: Error code returned by the driver function.
*
*/
typedef int (*eventdev_timer_adapter_caps_get_t)(
const struct rte_eventdev *dev,
uint64_t flags,
uint32_t *caps,
const struct rte_event_timer_adapter_ops **ops);
/**
* Add ethernet Rx queues to event device. This callback is invoked if
* the caps returned from rte_eventdev_eth_rx_adapter_caps_get(, eth_port_id)
@ -640,6 +672,9 @@ struct rte_eventdev_ops {
eventdev_eth_rx_adapter_stats_reset eth_rx_adapter_stats_reset;
/**< Reset ethernet Rx stats */
eventdev_timer_adapter_caps_get_t timer_adapter_caps_get;
/**< Get timer adapter capabilities */
eventdev_selftest dev_selftest;
/**< Start eventdev Selftest */

20
lib/librte_eventdev/rte_eventdev_version.map
View File

@ -66,7 +66,6 @@ DPDK_17.11 {
rte_event_eth_rx_adapter_stats_get;
rte_event_eth_rx_adapter_stats_reset;
rte_event_eth_rx_adapter_stop;
} DPDK_17.08;
DPDK_18.02 {
@ -80,3 +79,22 @@ DPDK_18.05 {
rte_event_dev_stop_flush_callback_register;
} DPDK_18.02;
EXPERIMENTAL {
global:
rte_event_timer_adapter_caps_get;
rte_event_timer_adapter_create;
rte_event_timer_adapter_create_ext;
rte_event_timer_adapter_free;
rte_event_timer_adapter_get_info;
rte_event_timer_adapter_lookup;
rte_event_timer_adapter_service_id_get;
rte_event_timer_adapter_start;
rte_event_timer_adapter_stats_get;
rte_event_timer_adapter_stats_reset;
rte_event_timer_adapter_stop;
rte_event_timer_arm_burst;
rte_event_timer_arm_tmo_tick_burst;
rte_event_timer_cancel_burst;
} DPDK_18.05;