DPDK  19.08.0-rc0
Data Structures | Macros | Typedefs | Enumerations | Functions
rte_event_timer_adapter.h File Reference
#include <rte_spinlock.h>
#include <rte_memory.h>
#include "rte_eventdev.h"

Go to the source code of this file.

Data Structures

struct  rte_event_timer_adapter_conf
 
struct  rte_event_timer_adapter_stats
 
struct  rte_event_timer_adapter_info
 
struct  rte_event_timer
 

Macros

#define RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES   (1ULL << 0)
 
#define RTE_EVENT_TIMER_ADAPTER_F_SP_PUT   (1ULL << 1)
 

Typedefs

typedef int(* rte_event_timer_adapter_port_conf_cb_t) (uint16_t id, uint8_t event_dev_id, uint8_t *event_port_id, void *conf_arg)
 

Enumerations

enum  rte_event_timer_adapter_clk_src {
  RTE_EVENT_TIMER_ADAPTER_CPU_CLK, RTE_EVENT_TIMER_ADAPTER_EXT_CLK0, RTE_EVENT_TIMER_ADAPTER_EXT_CLK1, RTE_EVENT_TIMER_ADAPTER_EXT_CLK2,
  RTE_EVENT_TIMER_ADAPTER_EXT_CLK3
}
 
enum  rte_event_timer_state {
  RTE_EVENT_TIMER_NOT_ARMED = 0, RTE_EVENT_TIMER_ARMED = 1, RTE_EVENT_TIMER_CANCELED = 2, RTE_EVENT_TIMER_ERROR = -1,
  RTE_EVENT_TIMER_ERROR_TOOEARLY = -2, RTE_EVENT_TIMER_ERROR_TOOLATE = -3
}
 

Functions

struct rte_event_timer_adapter * rte_event_timer_adapter_create (const struct rte_event_timer_adapter_conf *conf)
 
struct rte_event_timer_adapter * 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)
 
int rte_event_timer_adapter_get_info (const struct rte_event_timer_adapter *adapter, struct rte_event_timer_adapter_info *adapter_info)
 
int rte_event_timer_adapter_start (const struct rte_event_timer_adapter *adapter)
 
int rte_event_timer_adapter_stop (const struct rte_event_timer_adapter *adapter)
 
struct rte_event_timer_adapter * rte_event_timer_adapter_lookup (uint16_t adapter_id)
 
int rte_event_timer_adapter_free (struct rte_event_timer_adapter *adapter)
 
int rte_event_timer_adapter_service_id_get (struct rte_event_timer_adapter *adapter, uint32_t *service_id)
 
int rte_event_timer_adapter_stats_get (struct rte_event_timer_adapter *adapter, struct rte_event_timer_adapter_stats *stats)
 
int rte_event_timer_adapter_stats_reset (struct rte_event_timer_adapter *adapter)
 
static uint16_t rte_event_timer_arm_burst (const struct rte_event_timer_adapter *adapter, struct rte_event_timer **evtims, uint16_t nb_evtims)
 
static uint16_t rte_event_timer_arm_tmo_tick_burst (const struct rte_event_timer_adapter *adapter, struct rte_event_timer **evtims, const uint64_t timeout_ticks, const uint16_t nb_evtims)
 
static uint16_t rte_event_timer_cancel_burst (const struct rte_event_timer_adapter *adapter, struct rte_event_timer **evtims, uint16_t nb_evtims)
 

Detailed Description

RTE Event Timer Adapter

An event timer adapter has the following abstract working model:

                          timer_tick_ns
                              +
                 +-------+    |
                 |       |    |
         +-------+ bkt 0 +----v---+
         |       |       |        |
         |       +-------+        |
     +---+---+                +---+---+  +---+---+---+---+
     |       |                |       |  |   |   |   |   |
     | bkt n |                | bkt 1 |<-> t0| t1| t2| tn|
     |       |                |       |  |   |   |   |   |
     +---+---+                +---+---+  +---+---+---+---+
         |     Timer adapter      |
     +---+---+                +---+---+
     |       |                |       |
     | bkt 4 |                | bkt 2 |<--- Current bucket
     |       |                |       |
     +---+---+                +---+---+
          |      +-------+       |
          |      |       |       |
          +------+ bkt 3 +-------+
                 |       |
                 +-------+

Multiple timer adapters can be created with a varying level of resolution for various expiry use cases that run in parallel.

Before using the timer adapter, the application has to create and configure an event device along with the event port. Based on the event device capability it might require creating an additional event port to be used by the timer adapter.

The application creates the event timer adapter using the rte_event_timer_adapter_create(). The event device id is passed to this function, inside this function the event device capability is checked, and if an in-built port is absent the application uses the default function to create a new producer port.

The application may also use the function rte_event_timer_adapter_create_ext() to have granular control over producer port creation in a case where the in-built port is absent.

After creating the timer adapter, the application has to start it using rte_event_timer_adapter_start(). The buckets are traversed from 0 to n; when the adapter ticks, the next bucket is visited. Each time, the list per bucket is processed, and timer expiry events are sent to the designated event queue.

The application can arm one or more event timers using the rte_event_timer_arm_burst(). The timeout_ticks represents the number of timer_tick_ns after which the timer has to expire. The timeout at which the timers expire can be grouped or be independent of each event timer instance. rte_event_timer_arm_tmo_tick_burst() addresses the former case and rte_event_timer_arm_burst() addresses the latter case.

The application can cancel the timers from expiring using the rte_event_timer_cancel_burst().

On the secondary process, rte_event_timer_adapter_lookup() can be used to get the timer adapter pointer from its id and use it to invoke fastpath operations such as arm and cancel.

Some of the use cases of event timer adapter are Beacon Timers, Generic SW Timeout, Wireless MAC Scheduling, 3G Frame Protocols, Packet Scheduling, Protocol Retransmission Timers, Supervision Timers. All these use cases require high resolution and low time drift.

Definition in file rte_event_timer_adapter.h.

Macro Definition Documentation

◆ RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES

#define RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES   (1ULL << 0)

The event timer adapter implementation may have constraints on the resolution (timer_tick_ns) and maximum timer expiry timeout(max_tmo_ns) based on the given timer adapter or system. If this flag is set, the implementation adjusts the resolution and maximum timeout to the best possible configuration. On successful timer adapter creation, the application can get the configured resolution and max timeout with rte_event_timer_adapter_get_info().

See also
struct rte_event_timer_adapter_info::min_resolution_ns
struct rte_event_timer_adapter_info::max_tmo_ns

Definition at line 135 of file rte_event_timer_adapter.h.

◆ RTE_EVENT_TIMER_ADAPTER_F_SP_PUT

#define RTE_EVENT_TIMER_ADAPTER_F_SP_PUT   (1ULL << 1)

rte_event_timer_arm_burst() API to be used in single producer mode.

See also
struct rte_event_timer_adapter_conf::flags

Definition at line 147 of file rte_event_timer_adapter.h.

Typedef Documentation

◆ rte_event_timer_adapter_port_conf_cb_t

typedef int(* rte_event_timer_adapter_port_conf_cb_t) (uint16_t id, uint8_t event_dev_id, uint8_t *event_port_id, void *conf_arg)

Callback function type for producer port creation.

Definition at line 196 of file rte_event_timer_adapter.h.

Enumeration Type Documentation

◆ rte_event_timer_adapter_clk_src

Timer adapter clock source

Enumerator
RTE_EVENT_TIMER_ADAPTER_CPU_CLK 

Use CPU clock as the clock source.

RTE_EVENT_TIMER_ADAPTER_EXT_CLK0 

Platform dependent external clock source 0.

RTE_EVENT_TIMER_ADAPTER_EXT_CLK1 

Platform dependent external clock source 1.

RTE_EVENT_TIMER_ADAPTER_EXT_CLK2 

Platform dependent external clock source 2.

RTE_EVENT_TIMER_ADAPTER_EXT_CLK3 

Platform dependent external clock source 3.

Definition at line 122 of file rte_event_timer_adapter.h.

◆ rte_event_timer_state

Event timer state.

Enumerator
RTE_EVENT_TIMER_NOT_ARMED 

Event timer not armed.

RTE_EVENT_TIMER_ARMED 

Event timer successfully armed.

RTE_EVENT_TIMER_CANCELED 

Event timer successfully canceled.

RTE_EVENT_TIMER_ERROR 

Generic event timer error.

RTE_EVENT_TIMER_ERROR_TOOEARLY 

Event timer timeout tick value is too small for the adapter to handle, given its configured resolution.

RTE_EVENT_TIMER_ERROR_TOOLATE 

Event timer timeout tick is greater than the maximum timeout.

Definition at line 433 of file rte_event_timer_adapter.h.

Function Documentation

◆ rte_event_timer_adapter_create()

struct rte_event_timer_adapter* rte_event_timer_adapter_create ( const struct rte_event_timer_adapter_conf conf)

Create an event timer adapter.

This function must be invoked first before any other function in the API.

Parameters
confThe event timer adapter configuration structure.
Returns
A pointer to the new allocated event timer adapter on success. NULL on error with rte_errno set appropriately. Possible rte_errno values include:
  • ERANGE: timer_tick_ns is not in supported range.
  • ENOMEM: unable to allocate sufficient memory for adapter instances
  • EINVAL: invalid event device identifier specified in config
  • ENOSPC: maximum number of adapters already created
  • EIO: event device reconfiguration and restart error. The adapter reconfigures the event device with an additional port by default if it is required to use a service to manage timers. If the device had been started before this call, this error code indicates an error in restart following an error in reconfiguration, i.e., a combination of the two error codes.

◆ rte_event_timer_adapter_create_ext()

struct rte_event_timer_adapter* 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 
)

Create a timer adapter with the supplied callback.

This function can be used to have a more granular control over the timer adapter creation. If a built-in port is absent, then the function uses the callback provided to create and get the port id to be used as a producer port.

Parameters
confThe timer adapter configuration structure
conf_cbThe port config callback function.
conf_argOpaque pointer to the argument for the callback function
Returns
A pointer to the new allocated event timer adapter on success. NULL on error with rte_errno set appropriately. Possible rte_errno values include:
  • ERANGE: timer_tick_ns is not in supported range.
  • ENOMEM: unable to allocate sufficient memory for adapter instances
  • EINVAL: invalid event device identifier specified in config
  • ENOSPC: maximum number of adapters already created

◆ rte_event_timer_adapter_get_info()

int rte_event_timer_adapter_get_info ( const struct rte_event_timer_adapter *  adapter,
struct rte_event_timer_adapter_info adapter_info 
)

Retrieve the contextual information of an event timer adapter.

Parameters
adapterA pointer to the event timer adapter structure.
[out]adapter_infoA pointer to a structure of type rte_event_timer_adapter_info to be filled with the contextual information of the adapter.
Returns
  • 0: Success, driver updates the contextual information of the timer adapter
  • <0: Error code returned by the driver info get function.
  • -EINVAL: adapter identifier invalid
See also
RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES, struct rte_event_timer_adapter_info

◆ rte_event_timer_adapter_start()

int rte_event_timer_adapter_start ( const struct rte_event_timer_adapter *  adapter)

Start a timer adapter.

The adapter start step is the last one and consists of setting the timer adapter to start accepting the timers and schedules to event queues.

On success, all basic functions exported by the API (timer arm, timer cancel and so on) can be invoked.

Parameters
adapterA pointer to the event timer adapter structure.
Returns
  • 0: Success, adapter started.
  • <0: Error code returned by the driver start function.
  • -EINVAL if adapter identifier invalid
  • -ENOENT if software adapter but no service core mapped
  • -ENOTSUP if software adapter and more than one service core mapped
  • -EALREADY if adapter has already been started
Note
The eventdev to which the event_timer_adapter is connected needs to be started before calling rte_event_timer_adapter_start().

◆ rte_event_timer_adapter_stop()

int rte_event_timer_adapter_stop ( const struct rte_event_timer_adapter *  adapter)

Stop an event timer adapter.

The adapter can be restarted with a call to rte_event_timer_adapter_start().

Parameters
adapterA pointer to the event timer adapter structure.
Returns
  • 0: Success, adapter stopped.
  • <0: Error code returned by the driver stop function.
  • -EINVAL if adapter identifier invalid

◆ rte_event_timer_adapter_lookup()

struct rte_event_timer_adapter* rte_event_timer_adapter_lookup ( uint16_t  adapter_id)

Lookup an event timer adapter using its identifier.

If an event timer adapter was created in another process with the same identifier, this function will locate its state and set up access to it so that it can be used in this process.

Parameters
adapter_idThe event timer adapter identifier.
Returns
A pointer to the event timer adapter matching the identifier on success. NULL on error with rte_errno set appropriately. Possible rte_errno values include:
  • ENOENT - requested entry not available to return.

◆ rte_event_timer_adapter_free()

int rte_event_timer_adapter_free ( struct rte_event_timer_adapter *  adapter)

Free an event timer adapter.

Destroy an event timer adapter, freeing all resources.

Before invoking this function, the application must wait for all the armed timers to expire or cancel the outstanding armed timers.

Parameters
adapterA pointer to an event timer adapter structure.
Returns
  • 0: Successfully freed the event timer adapter resources.
  • <0: Failed to free the event timer adapter resources.
  • -EAGAIN: adapter is busy; timers outstanding
  • -EBUSY: stop hasn't been called for this adapter yet
  • -EINVAL: adapter id invalid, or adapter invalid

◆ rte_event_timer_adapter_service_id_get()

int rte_event_timer_adapter_service_id_get ( struct rte_event_timer_adapter *  adapter,
uint32_t *  service_id 
)

Retrieve the service ID of the event timer adapter. If the adapter doesn't use an rte_service function, this function returns -ESRCH.

Parameters
adapterA pointer to an event timer adapter.
[out]service_idA pointer to a uint32_t, to be filled in with the service id.
Returns
  • 0: Success
  • <0: Error code on failure
  • -ESRCH: the adapter does not require a service to operate

◆ rte_event_timer_adapter_stats_get()

int rte_event_timer_adapter_stats_get ( struct rte_event_timer_adapter *  adapter,
struct rte_event_timer_adapter_stats stats 
)

Retrieve statistics for an event timer adapter instance.

Parameters
adapterA pointer to an event timer adapter structure.
[out]statsA pointer to a structure to fill with statistics.
Returns
  • 0: Successfully retrieved.
  • <0: Failure; error code returned.

◆ rte_event_timer_adapter_stats_reset()

int rte_event_timer_adapter_stats_reset ( struct rte_event_timer_adapter *  adapter)

Reset statistics for an event timer adapter instance.

Parameters
adapterA pointer to an event timer adapter structure.
Returns
  • 0: Successfully reset;
  • <0: Failure; error code returned.

◆ rte_event_timer_arm_burst()

static uint16_t rte_event_timer_arm_burst ( const struct rte_event_timer_adapter *  adapter,
struct rte_event_timer **  evtims,
uint16_t  nb_evtims 
)
inlinestatic

Arm a burst of event timers with separate expiration timeout tick for each event timer.

Before calling this function, the application allocates struct rte_event_timer objects from mempool or huge page backed application buffers of desired size. On successful allocation, application updates the struct rte_event_timer` attributes such as expiry event attributes, timeout ticks from now. This function submits the event timer arm requests to the event timer adapter and on expiry, the events will be injected to designated event queue.

Parameters
adapterA pointer to an event timer adapter structure.
evtimsPointer to an array of objects of type rte_event_timer structure.
nb_evtimsNumber of event timers in the supplied array.
Returns
The number of successfully armed event timers. The return value can be less than the value of the nb_evtims parameter. If the return value is less than nb_evtims, the remaining event timers at the end of evtims are not consumed, and the caller has to take care of them, and rte_errno is set accordingly. Possible errno values include:
  • EINVAL Invalid timer adapter, expiry event queue ID is invalid, or an expiry event's sched type doesn't match the capabilities of the destination event queue.
  • EAGAIN Specified timer adapter is not running
  • EALREADY A timer was encountered that was already armed

Definition at line 574 of file rte_event_timer_adapter.h.

◆ rte_event_timer_arm_tmo_tick_burst()

static uint16_t rte_event_timer_arm_tmo_tick_burst ( const struct rte_event_timer_adapter *  adapter,
struct rte_event_timer **  evtims,
const uint64_t  timeout_ticks,
const uint16_t  nb_evtims 
)
inlinestatic

Arm a burst of event timers with same expiration timeout tick.

Provides the same functionality as rte_event_timer_arm_burst(), except that application can use this API when all the event timers have the same timeout expiration tick. This specialized function can provide the additional hint to the adapter implementation and optimize if possible.

Parameters
adapterA pointer to an event timer adapter structure.
evtimsPoints to an array of objects of type rte_event_timer structure.
timeout_ticksThe number of ticks in which the timers should expire.
nb_evtimsNumber of event timers in the supplied array.
Returns
The number of successfully armed event timers. The return value can be less than the value of the nb_evtims parameter. If the return value is less than nb_evtims, the remaining event timers at the end of evtims are not consumed, and the caller has to take care of them, and rte_errno is set accordingly. Possible errno values include:
  • EINVAL Invalid timer adapter, expiry event queue ID is invalid, or an expiry event's sched type doesn't match the capabilities of the destination event queue.
  • EAGAIN Specified event timer adapter is not running
  • EALREADY A timer was encountered that was already armed

Definition at line 615 of file rte_event_timer_adapter.h.

◆ rte_event_timer_cancel_burst()

static uint16_t rte_event_timer_cancel_burst ( const struct rte_event_timer_adapter *  adapter,
struct rte_event_timer **  evtims,
uint16_t  nb_evtims 
)
inlinestatic

Cancel a burst of event timers from being scheduled to the event device.

Parameters
adapterA pointer to an event timer adapter structure.
evtimsPoints to an array of objects of type rte_event_timer structure
nb_evtimsNumber of event timer instances in the supplied array.
Returns
The number of successfully canceled event timers. The return value can be less than the value of the nb_evtims parameter. If the return value is less than nb_evtims, the remaining event timers at the end of evtims are not consumed, and the caller has to take care of them, and rte_errno is set accordingly. Possible errno values include:
  • EINVAL Invalid timer adapter identifier
  • EAGAIN Specified timer adapter is not running
  • EALREADY A timer was encountered that was already canceled

Definition at line 650 of file rte_event_timer_adapter.h.