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

latency: added new library for latency stats

Browse Source 
Add a library designed to calculate latency statistics and report them
to the application when queried. The library measures minimum, average and
maximum latencies, and jitter in nano seconds. The current implementation
supports global latency stats, i.e. per application stats.

Signed-off-by: Reshma Pattan <reshma.pattan@intel.com>
Signed-off-by: Remy Horton <remy.horton@intel.com>
Signed-off-by: Harry van Haaren <harry.van.haaren@intel.com>
This commit is contained in:
Reshma Pattan 2017-03-30 22:01:01 +01:00 committed by Thomas Monjalon
parent 7e4441c8ef
commit 5cd3cac9ed
12 changed files with 650 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
MAINTAINERS
View File

@ -683,6 +683,10 @@ Bit-rate statistics
M: Remy Horton <remy.horton@intel.com>
F: lib/librte_bitratestats/
Latency statistics
M: Reshma Pattan <reshma.pattan@intel.com>
F: lib/librte_latencystats/
Test Applications
-----------------

5
config/common_base
View File

@ -562,6 +562,11 @@ CONFIG_RTE_LIBRTE_METRICS=y
#
CONFIG_RTE_LIBRTE_BITRATE=y
#
# Compile the latency statistics library
#
CONFIG_RTE_LIBRTE_LATENCY_STATS=y
#
# Compile librte_lpm
#

1
doc/api/doxy-api-index.md
View File

@ -159,4 +159,5 @@ There are many libraries, so their headers may be grouped by topics:
[keepalive] (@ref rte_keepalive.h),
[device metrics] (@ref rte_metrics.h),
[bitrate statistics] (@ref rte_bitrate.h),
[latency statistics] (@ref rte_latencystats.h),
[version] (@ref rte_version.h)

1
doc/api/doxy-api.conf
View File

@ -50,6 +50,7 @@ INPUT = doc/api/doxy-api-index.md \
lib/librte_jobstats \
lib/librte_kni \
lib/librte_kvargs \
lib/librte_latencystats \
lib/librte_lpm \
lib/librte_mbuf \
lib/librte_mempool \

54
doc/guides/prog_guide/metrics_lib.rst
View File

@ -243,3 +243,57 @@ desired, this function should be called once a second.
}
/* ... */
}
Latency statistics library
--------------------------
The latency statistics library calculates the latency of packet
processing by a DPDK application, reporting the minimum, average,
and maximum nano-seconds that packet processing takes, as well as
the jitter in processing delay. These statistics are then reported
via the metrics library using the following names:
- ``min_latency_ns``: Minimum processing latency (nano-seconds)
- ``avg_latency_ns``: Average processing latency (nano-seconds)
- ``mac_latency_ns``: Maximum processing latency (nano-seconds)
- ``jitter_ns``: Variance in processing latency (nano-seconds)
Once initialised and clocked at the appropriate frequency, these
statistics can be obtained by querying the metrics library.
Initialization
~~~~~~~~~~~~~~
Before the library can be used, it has to be initialised by calling
``rte_latencystats_init()``.
.. code-block:: c
lcoreid_t latencystats_lcore_id = -1;
int ret = rte_latencystats_init(1, NULL);
if (ret)
rte_exit(EXIT_FAILURE, "Could not allocate latency data.\n");
Triggering statistic updates
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The ``rte_latencystats_update()`` function needs to be called
periodically so that latency statistics can be updated.
.. code-block:: c
if (latencystats_lcore_id == rte_lcore_id())
rte_latencystats_update();
Library shutdown
~~~~~~~~~~~~~~~~
When finished, ``rte_latencystats_uninit()`` needs to be called to
de-initialise the latency library.
.. code-block:: c
rte_latencystats_uninit();

6
doc/guides/rel_notes/release_17_05.rst
View File

@ -232,6 +232,11 @@ New Features
A library that can be used to calculate device bit-rates. Calculated
bitrates are reported using the metrics library.
* **Added latency stats library.**
A library that measures packet latency. The collected statistics are jitter
and latency. For latency the minimum, average, and maximum is measured.
Resolved Issues
---------------
@ -450,6 +455,7 @@ The libraries prepended with a plus sign were incremented in this version.
librte_jobstats.so.1
librte_kni.so.2
librte_kvargs.so.1
+ librte_latencystats.so.1
librte_lpm.so.2
+ librte_mbuf.so.3
librte_mempool.so.2

2
lib/Makefile
View File

@ -74,6 +74,8 @@ DIRS-$(CONFIG_RTE_LIBRTE_METRICS) += librte_metrics
DEPDIRS-librte_metrics := librte_eal
DIRS-$(CONFIG_RTE_LIBRTE_BITRATE) += librte_bitratestats
DEPDIRS-librte_bitratestats := librte_eal librte_metrics librte_ether
DIRS-$(CONFIG_RTE_LIBRTE_LATENCY_STATS) += librte_latencystats
DEPDIRS-librte_latencystats := librte_eal librte_metrics librte_ether librte_mbuf
DIRS-$(CONFIG_RTE_LIBRTE_POWER) += librte_power
DEPDIRS-librte_power := librte_eal
DIRS-$(CONFIG_RTE_LIBRTE_METER) += librte_meter

50
lib/librte_latencystats/Makefile Normal file
View File

@ -0,0 +1,50 @@
# BSD LICENSE
#
# Copyright(c) 2017 Intel Corporation. All rights reserved.
#
# 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 Intel Corporation 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.
include $(RTE_SDK)/mk/rte.vars.mk
# library name
LIB = librte_latencystats.a
CFLAGS += $(WERROR_FLAGS) -I$(SRCDIR) -O3
LDLIBS += -lm
LDLIBS += -lpthread
EXPORT_MAP := rte_latencystats_version.map
LIBABIVER := 1
# all source are stored in SRCS-y
SRCS-$(CONFIG_RTE_LIBRTE_LATENCY_STATS) := rte_latencystats.c
# install this header file
SYMLINK-$(CONFIG_RTE_LIBRTE_LATENCY_STATS)-include := rte_latencystats.h
include $(RTE_SDK)/mk/rte.lib.mk

361
lib/librte_latencystats/rte_latencystats.c Normal file
View File

@ -0,0 +1,361 @@
/*-
* BSD LICENSE
*
* Copyright(c) 2017 Intel Corporation. All rights reserved.
*
* 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 Intel Corporation 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.
*/
#include <unistd.h>
#include <sys/types.h>
#include <stdbool.h>
#include <math.h>
#include <rte_mbuf.h>
#include <rte_log.h>
#include <rte_cycles.h>
#include <rte_ethdev.h>
#include <rte_metrics.h>
#include <rte_memzone.h>
#include <rte_lcore.h>
#include <rte_timer.h>
#include "rte_latencystats.h"
/** Nano seconds per second */
#define NS_PER_SEC 1E9
/** Clock cycles per nano second */
static uint64_t
latencystat_cycles_per_ns(void)
{
return rte_get_timer_hz() / NS_PER_SEC;
}
/* Macros for printing using RTE_LOG */
#define RTE_LOGTYPE_LATENCY_STATS RTE_LOGTYPE_USER1
static const char *MZ_RTE_LATENCY_STATS = "rte_latencystats";
static int latency_stats_index;
static uint64_t samp_intvl;
static uint64_t timer_tsc;
static uint64_t prev_tsc;
struct rte_latency_stats {
float min_latency; /**< Minimum latency in nano seconds */
float avg_latency; /**< Average latency in nano seconds */
float max_latency; /**< Maximum latency in nano seconds */
float jitter; /** Latency variation */
};
static struct rte_latency_stats *glob_stats;
struct rxtx_cbs {
struct rte_eth_rxtx_callback *cb;
};
static struct rxtx_cbs rx_cbs[RTE_MAX_ETHPORTS][RTE_MAX_QUEUES_PER_PORT];
static struct rxtx_cbs tx_cbs[RTE_MAX_ETHPORTS][RTE_MAX_QUEUES_PER_PORT];
struct latency_stats_nameoff {
char name[RTE_ETH_XSTATS_NAME_SIZE];
unsigned int offset;
};
static const struct latency_stats_nameoff lat_stats_strings[] = {
{"min_latency_ns", offsetof(struct rte_latency_stats, min_latency)},
{"avg_latency_ns", offsetof(struct rte_latency_stats, avg_latency)},
{"max_latency_ns", offsetof(struct rte_latency_stats, max_latency)},
{"jitter_ns", offsetof(struct rte_latency_stats, jitter)},
};
#define NUM_LATENCY_STATS (sizeof(lat_stats_strings) / \
sizeof(lat_stats_strings[0]))
int32_t
rte_latencystats_update(void)
{
unsigned int i;
float *stats_ptr = NULL;
uint64_t values[NUM_LATENCY_STATS] = {0};
int ret;
for (i = 0; i < NUM_LATENCY_STATS; i++) {
stats_ptr = RTE_PTR_ADD(glob_stats,
lat_stats_strings[i].offset);
values[i] = (uint64_t)floor((*stats_ptr)/
latencystat_cycles_per_ns());
}
ret = rte_metrics_update_values(RTE_METRICS_GLOBAL,
latency_stats_index,
values, NUM_LATENCY_STATS);
if (ret < 0)
RTE_LOG(INFO, LATENCY_STATS, "Failed to push the stats\n");
return ret;
}
static void
rte_latencystats_fill_values(struct rte_metric_value *values)
{
unsigned int i;
float *stats_ptr = NULL;
for (i = 0; i < NUM_LATENCY_STATS; i++) {
stats_ptr = RTE_PTR_ADD(glob_stats,
lat_stats_strings[i].offset);
values[i].key = i;
values[i].value = (uint64_t)floor((*stats_ptr)/
latencystat_cycles_per_ns());
}
}
static uint16_t
add_time_stamps(uint8_t pid __rte_unused,
uint16_t qid __rte_unused,
struct rte_mbuf **pkts,
uint16_t nb_pkts,
uint16_t max_pkts __rte_unused,
void *user_cb __rte_unused)
{
unsigned int i;
uint64_t diff_tsc, now;
/*
* For every sample interval,
* time stamp is marked on one received packet.
*/
now = rte_rdtsc();
for (i = 0; i < nb_pkts; i++) {
diff_tsc = now - prev_tsc;
timer_tsc += diff_tsc;
if (timer_tsc >= samp_intvl) {
pkts[i]->timestamp = now;
timer_tsc = 0;
}
prev_tsc = now;
now = rte_rdtsc();
}
return nb_pkts;
}
static uint16_t
calc_latency(uint8_t pid __rte_unused,
uint16_t qid __rte_unused,
struct rte_mbuf **pkts,
uint16_t nb_pkts,
void *_ __rte_unused)
{
unsigned int i, cnt = 0;
uint64_t now;
float latency[nb_pkts];
static float prev_latency;
/*
* Alpha represents degree of weighting decrease in EWMA,
* a constant smoothing factor between 0 and 1. The value
* is used below for measuring average latency.
*/
const float alpha = 0.2;
now = rte_rdtsc();
for (i = 0; i < nb_pkts; i++) {
if (pkts[i]->timestamp)
latency[cnt++] = now - pkts[i]->timestamp;
}
for (i = 0; i < cnt; i++) {
/*
* The jitter is calculated as statistical mean of interpacket
* delay variation. The "jitter estimate" is computed by taking
* the absolute values of the ipdv sequence and applying an
* exponential filter with parameter 1/16 to generate the
* estimate. i.e J=J+(|D(i-1,i)|-J)/16. Where J is jitter,
* D(i-1,i) is difference in latency of two consecutive packets
* i-1 and i.
* Reference: Calculated as per RFC 5481, sec 4.1,
* RFC 3393 sec 4.5, RFC 1889 sec.
*/
glob_stats->jitter += (fabsf(prev_latency - latency[i])
- glob_stats->jitter)/16;
if (glob_stats->min_latency == 0)
glob_stats->min_latency = latency[i];
else if (latency[i] < glob_stats->min_latency)
glob_stats->min_latency = latency[i];
else if (latency[i] > glob_stats->max_latency)
glob_stats->max_latency = latency[i];
/*
* The average latency is measured using exponential moving
* average, i.e. using EWMA
* https://en.wikipedia.org/wiki/Moving_average
*/
glob_stats->avg_latency +=
alpha * (latency[i] - glob_stats->avg_latency);
prev_latency = latency[i];
}
return nb_pkts;
}
int
rte_latencystats_init(uint64_t app_samp_intvl,
rte_latency_stats_flow_type_fn user_cb)
{
unsigned int i;
uint8_t pid;
uint16_t qid;
struct rxtx_cbs *cbs = NULL;
const uint8_t nb_ports = rte_eth_dev_count();
const char *ptr_strings[NUM_LATENCY_STATS] = {0};
const struct rte_memzone *mz = NULL;
const unsigned int flags = 0;
if (rte_memzone_lookup(MZ_RTE_LATENCY_STATS))
return -EEXIST;
/** Allocate stats in shared memory fo multi process support */
mz = rte_memzone_reserve(MZ_RTE_LATENCY_STATS, sizeof(*glob_stats),
rte_socket_id(), flags);
if (mz == NULL) {
RTE_LOG(ERR, LATENCY_STATS, "Cannot reserve memory: %s:%d\n",
__func__, __LINE__);
return -ENOMEM;
}
glob_stats = mz->addr;
samp_intvl = app_samp_intvl * latencystat_cycles_per_ns();
/** Register latency stats with stats library */
for (i = 0; i < NUM_LATENCY_STATS; i++)
ptr_strings[i] = lat_stats_strings[i].name;
latency_stats_index = rte_metrics_reg_names(ptr_strings,
NUM_LATENCY_STATS);
if (latency_stats_index < 0) {
RTE_LOG(DEBUG, LATENCY_STATS,
"Failed to register latency stats names\n");
return -1;
}
/** Register Rx/Tx callbacks */
for (pid = 0; pid < nb_ports; pid++) {
struct rte_eth_dev_info dev_info;
rte_eth_dev_info_get(pid, &dev_info);
for (qid = 0; qid < dev_info.nb_rx_queues; qid++) {
cbs = &rx_cbs[pid][qid];
cbs->cb = rte_eth_add_first_rx_callback(pid, qid,
add_time_stamps, user_cb);
if (!cbs->cb)
RTE_LOG(INFO, LATENCY_STATS, "Failed to "
"register Rx callback for pid=%d, "
"qid=%d\n", pid, qid);
}
for (qid = 0; qid < dev_info.nb_tx_queues; qid++) {
cbs = &tx_cbs[pid][qid];
cbs->cb = rte_eth_add_tx_callback(pid, qid,
calc_latency, user_cb);
if (!cbs->cb)
RTE_LOG(INFO, LATENCY_STATS, "Failed to "
"register Tx callback for pid=%d, "
"qid=%d\n", pid, qid);
}
}
return 0;
}
int
rte_latencystats_uninit(void)
{
uint8_t pid;
uint16_t qid;
int ret = 0;
struct rxtx_cbs *cbs = NULL;
const uint8_t nb_ports = rte_eth_dev_count();
/** De register Rx/Tx callbacks */
for (pid = 0; pid < nb_ports; pid++) {
struct rte_eth_dev_info dev_info;
rte_eth_dev_info_get(pid, &dev_info);
for (qid = 0; qid < dev_info.nb_rx_queues; qid++) {
cbs = &rx_cbs[pid][qid];
ret = rte_eth_remove_rx_callback(pid, qid, cbs->cb);
if (ret)
RTE_LOG(INFO, LATENCY_STATS, "failed to "
"remove Rx callback for pid=%d, "
"qid=%d\n", pid, qid);
}
for (qid = 0; qid < dev_info.nb_tx_queues; qid++) {
cbs = &tx_cbs[pid][qid];
ret = rte_eth_remove_tx_callback(pid, qid, cbs->cb);
if (ret)
RTE_LOG(INFO, LATENCY_STATS, "failed to "
"remove Tx callback for pid=%d, "
"qid=%d\n", pid, qid);
}
}
return 0;
}
int
rte_latencystats_get_names(struct rte_metric_name *names, uint16_t size)
{
unsigned int i;
if (names == NULL || size < NUM_LATENCY_STATS)
return NUM_LATENCY_STATS;
for (i = 0; i < NUM_LATENCY_STATS; i++)
snprintf(names[i].name, sizeof(names[i].name),
"%s", lat_stats_strings[i].name);
return NUM_LATENCY_STATS;
}
int
rte_latencystats_get(struct rte_metric_value *values, uint16_t size)
{
if (size < NUM_LATENCY_STATS || values == NULL)
return NUM_LATENCY_STATS;
if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
const struct rte_memzone *mz;
mz = rte_memzone_lookup(MZ_RTE_LATENCY_STATS);
if (mz == NULL) {
RTE_LOG(ERR, LATENCY_STATS,
"Latency stats memzone not found\n");
return -ENOMEM;
}
glob_stats = mz->addr;
}
/* Retrieve latency stats */
rte_latencystats_fill_values(values);
return NUM_LATENCY_STATS;
}

154
lib/librte_latencystats/rte_latencystats.h Normal file
View File

@ -0,0 +1,154 @@
/*-
* BSD LICENSE
*
* Copyright(c) 2017 Intel Corporation. All rights reserved.
*
* 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 Intel Corporation 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_LATENCYSTATS_H_
#define _RTE_LATENCYSTATS_H_
/**
* @file
* RTE latency stats
*
* library to provide application and flow based latency stats.
*/
#include <rte_metrics.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* Note: This function pointer is for future flow based latency stats
* implementation.
*
* Function type used for identifting flow types of a Rx packet.
*
* The callback function is called on Rx for each packet.
* This function is used for flow based latency calculations.
*
* @param pkt
* Packet that has to be identified with its flow types.
* @param user_param
* The arbitrary user parameter passed in by the application when
* the callback was originally configured.
* @return
* The flow_mask, representing the multiple flow types of a packet.
*/
typedef uint16_t (*rte_latency_stats_flow_type_fn)(struct rte_mbuf *pkt,
void *user_param);
/**
* Registers Rx/Tx callbacks for each active port, queue.
*
* @param samp_intvl
* Sampling time period in nano seconds, at which packet
* should be marked with time stamp.
* @param user_cb
* Note: This param is for future flow based latency stats
* implementation.
* User callback to be called to get flow types of a packet.
* Used for flow based latency calculation.
* If the value is NULL, global stats will be calculated,
* else flow based latency stats will be calculated.
* For now just pass on the NULL value to this param.
* @return
* -1 : On error
* -ENOMEM: On error
* 0 : On success
*/
int rte_latencystats_init(uint64_t samp_intvl,
rte_latency_stats_flow_type_fn user_cb);
/**
* Calculates the latency and jitter values internally, exposing the updated
* values via *rte_latencystats_get* or the rte_metrics API.
* @return:
* 0 : on Success
* < 0 : Error in updating values.
*/
int32_t rte_latencystats_update(void);
/**
* Removes registered Rx/Tx callbacks for each active port, queue.
*
* @return
* -1: On error
* 0: On success
*/
int rte_latencystats_uninit(void);
/**
* Retrieve names of latency statistics
*
* @param names
* Block of memory to insert names into. Must be at least size in capacity.
* If set to NULL, function returns required capacity.
* @param size
* Capacity of latency stats names (number of names).
* @return
* - positive value lower or equal to size: success. The return value
* is the number of entries filled in the stats table.
* - positive value higher than size: error, the given statistics table
* is too small. The return value corresponds to the size that should
* be given to succeed. The entries in the table are not valid and
* shall not be used by the caller.
*/
int rte_latencystats_get_names(struct rte_metric_name *names,
uint16_t size);
/**
* Retrieve latency statistics.
*
* @param values
* A pointer to a table of structure of type *rte_metric_value*
* to be filled with latency statistics ids and values.
* This parameter can be set to NULL if size is 0.
* @param size
* The size of the stats table, which should be large enough to store
* all the latency stats.
* @return
* - positive value lower or equal to size: success. The return value
* is the number of entries filled in the stats table.
* - positive value higher than size: error, the given statistics table
* is too small. The return value corresponds to the size that should
* be given to succeed. The entries in the table are not valid and
* shall not be used by the caller.
* -ENOMEM: On failure.
*/
int rte_latencystats_get(struct rte_metric_value *values,
uint16_t size);
#ifdef __cplusplus
}
#endif
#endif /* _RTE_LATENCYSTATS_H_ */

11
lib/librte_latencystats/rte_latencystats_version.map Normal file
View File

@ -0,0 +1,11 @@
DPDK_17.05 {
global:
rte_latencystats_get;
rte_latencystats_get_names;
rte_latencystats_init;
rte_latencystats_uninit;
rte_latencystats_update;
local: *;
};

1
mk/rte.app.mk
View File

@ -75,6 +75,7 @@ _LDLIBS-$(CONFIG_RTE_LIBRTE_ACL) += --no-whole-archive
_LDLIBS-$(CONFIG_RTE_LIBRTE_JOBSTATS) += -lrte_jobstats
_LDLIBS-$(CONFIG_RTE_LIBRTE_METRICS) += -lrte_metrics
_LDLIBS-$(CONFIG_RTE_LIBRTE_BITRATE) += -lrte_bitratestats
_LDLIBS-$(CONFIG_RTE_LIBRTE_LATENCY_STATS) += -lrte_latencystats
_LDLIBS-$(CONFIG_RTE_LIBRTE_POWER) += -lrte_power
_LDLIBS-$(CONFIG_RTE_LIBRTE_TIMER) += -lrte_timer