> -----Original Message-----
> From: Honnappa Nagarahalli [mailto:honnappa.nagaraha...@arm.com]
> Sent: Thursday, October 3, 2019 7:42 AM
> To: Ananyev, Konstantin <konstantin.anan...@intel.com>;
> step...@networkplumber.org; paul...@linux.ibm.com
> Cc: Wang, Yipeng1 <yipeng1.w...@intel.com>; Medvedkin, Vladimir
> <vladimir.medved...@intel.com>; Ruifeng Wang (Arm Technology
> China) <ruifeng.w...@arm.com>; Dharmik Thakkar <dharmik.thak...@arm.com>;
> Honnappa Nagarahalli
> <honnappa.nagaraha...@arm.com>; dev@dpdk.org; nd <n...@arm.com>; nd
> <n...@arm.com>
> Subject: RE: [PATCH v3 2/3] lib/rcu: add resource reclamation APIs
>
> >
> > > +
> > > +/* Reclaim resources from the defer queue. */ int
> > > +rte_rcu_qsbr_dq_reclaim(struct rte_rcu_qsbr_dq *dq) {
> > > + uint32_t max_cnt;
> > > + uint32_t cnt;
> > > + void *token;
> > > + uint64_t *tmp;
> > > + uint32_t i;
> > > +
> > > + if (dq == NULL) {
> > > + rte_log(RTE_LOG_ERR, rte_rcu_log_type,
> > > + "%s(): Invalid input parameter\n", __func__);
> > > + rte_errno = EINVAL;
> > > +
> > > + return 1;
> > > + }
> > > +
> > > + /* Anything to reclaim? */
> > > + if (rte_ring_count(dq->r) == 0)
> > > + return 0;
> > > +
> > > + /* Reclaim at the max 1/16th the total number of entries. */
> > > + max_cnt = dq->size >> RTE_RCU_QSBR_MAX_RECLAIM_LIMIT;
> > > + max_cnt = (max_cnt == 0) ? dq->size : max_cnt;
> > > + cnt = 0;
> > > +
> > > + /* Check reader threads quiescent state and reclaim resources */
> > > + while ((cnt < max_cnt) && (rte_ring_peek(dq->r, &token) == 0) &&
> > > + (rte_rcu_qsbr_check(dq->v, (uint64_t)((uintptr_t)token), false)
> >
> > One more thing I forgot to ask - how this construct supposed to work on 32
> > bit machines?
> > peek() will return 32-bit value, while qsbr_check() operates with 64bit
> > tokens...
> > As I understand in that case you need to peek() 2 elems.
> Yes, that is the intention. Ring APIs with desired element size will help
> address the 32b machines.
Or serialized dequeue :)
>
> > Might work, but still think better to introduce serialize version of
> > ring_dequeue() See my other mail about re_ring_peek().
> >
> >
> > > + == 1)) {
> > > + (void)rte_ring_sc_dequeue(dq->r, &token);
> > > + /* The resource to dequeue needs to be a multiple of 64b
> > > + * due to the limitation of the rte_ring implementation.
> > > + */
> > > + for (i = 0, tmp = (uint64_t *)dq->e; i < dq->esize/8;
> > > + i++, tmp++)
> > > + (void)rte_ring_sc_dequeue(dq->r,
> > > + (void *)(uintptr_t)tmp);
> > > + dq->f(dq->p, dq->e);
> > > +
> > > + cnt++;
> > > + }
> > > +
> > > + rte_log(RTE_LOG_INFO, rte_rcu_log_type,
> > > + "%s(): Reclaimed %u resources\n", __func__, cnt);
> > > +
> > > + if (cnt == 0) {
> > > + /* No resources were reclaimed */
> > > + rte_errno = EAGAIN;
> > > + return 1;
> > > + }
> > > +
> > > + return 0;
> > > +}
> > > +
> > > +/* Delete a defer queue. */
> > > +int
> > > +rte_rcu_qsbr_dq_delete(struct rte_rcu_qsbr_dq *dq) {
> > > + if (dq == NULL) {
> > > + rte_log(RTE_LOG_ERR, rte_rcu_log_type,
> > > + "%s(): Invalid input parameter\n", __func__);
> > > + rte_errno = EINVAL;
> > > +
> > > + return 1;
> > > + }
> > > +
> > > + /* Reclaim all the resources */
> > > + if (rte_rcu_qsbr_dq_reclaim(dq) != 0)
> > > + /* Error number is already set by the reclaim API */
> > > + return 1;
> > > +
> > > + rte_ring_free(dq->r);
> > > + rte_free(dq);
> > > +
> > > + return 0;
> > > +}
> > > +
> > > int rte_rcu_log_type;
> > >
> > > RTE_INIT(rte_rcu_register)
> > > diff --git a/lib/librte_rcu/rte_rcu_qsbr.h
> > > b/lib/librte_rcu/rte_rcu_qsbr.h index c80f15c00..185d4b50a 100644
> > > --- a/lib/librte_rcu/rte_rcu_qsbr.h
> > > +++ b/lib/librte_rcu/rte_rcu_qsbr.h
> > > @@ -34,6 +34,7 @@ extern "C" {
> > > #include <rte_lcore.h>
> > > #include <rte_debug.h>
> > > #include <rte_atomic.h>
> > > +#include <rte_ring.h>
> > >
> > > extern int rte_rcu_log_type;
> > >
> > > @@ -109,6 +110,67 @@ struct rte_rcu_qsbr {
> > > */
> > > } __rte_cache_aligned;
> > >
> > > +/**
> > > + * Call back function called to free the resources.
> > > + *
> > > + * @param p
> > > + * Pointer provided while creating the defer queue
> > > + * @param e
> > > + * Pointer to the resource data stored on the defer queue
> > > + *
> > > + * @return
> > > + * None
> > > + */
> > > +typedef void (*rte_rcu_qsbr_free_resource)(void *p, void *e);
> > > +
> > > +#define RTE_RCU_QSBR_DQ_NAMESIZE RTE_RING_NAMESIZE
> > > +
> > > +/**
> > > + * Trigger automatic reclamation after 1/8th the defer queue is full.
> > > + */
> > > +#define RTE_RCU_QSBR_AUTO_RECLAIM_LIMIT 3
> > > +
> > > +/**
> > > + * Reclaim at the max 1/16th the total number of resources.
> > > + */
> > > +#define RTE_RCU_QSBR_MAX_RECLAIM_LIMIT 4
> > > +
> > > +/**
> > > + * Parameters used when creating the defer queue.
> > > + */
> > > +struct rte_rcu_qsbr_dq_parameters {
> > > + const char *name;
> > > + /**< Name of the queue. */
> > > + uint32_t size;
> > > + /**< Number of entries in queue. Typically, this will be
> > > + * the same as the maximum number of entries supported in the
> > > + * lock free data structure.
> > > + * Data structures with unbounded number of entries is not
> > > + * supported currently.
> > > + */
> > > + uint32_t esize;
> > > + /**< Size (in bytes) of each element in the defer queue.
> > > + * This has to be multiple of 8B as the rte_ring APIs
> > > + * support 8B element sizes only.
> > > + */
> > > + rte_rcu_qsbr_free_resource f;
> > > + /**< Function to call to free the resource. */
> > > + void *p;
> > > + /**< Pointer passed to the free function. Typically, this is the
> > > + * pointer to the data structure to which the resource to free
> > > + * belongs. This can be NULL.
> > > + */
> > > + struct rte_rcu_qsbr *v;
> > > + /**< RCU QSBR variable to use for this defer queue */ };
> > > +
> > > +/* RTE defer queue structure.
> > > + * This structure holds the defer queue. The defer queue is used to
> > > + * hold the deleted entries from the data structure that are not
> > > + * yet freed.
> > > + */
> > > +struct rte_rcu_qsbr_dq;
> > > +
> > > /**
> > > * @warning
> > > * @b EXPERIMENTAL: this API may change without prior notice @@
> > > -648,6 +710,113 @@ __rte_experimental int rte_rcu_qsbr_dump(FILE *f,
> > > struct rte_rcu_qsbr *v);
> > >
> > > +/**
> > > + * @warning
> > > + * @b EXPERIMENTAL: this API may change without prior notice
> > > + *
> > > + * Create a queue used to store the data structure elements that can
> > > + * be freed later. This queue is referred to as 'defer queue'.
> > > + *
> > > + * @param params
> > > + * Parameters to create a defer queue.
> > > + * @return
> > > + * On success - Valid pointer to defer queue
> > > + * On error - NULL
> > > + * Possible rte_errno codes are:
> > > + * - EINVAL - NULL parameters are passed
> > > + * - ENOMEM - Not enough memory
> > > + */
> > > +__rte_experimental
> > > +struct rte_rcu_qsbr_dq *
> > > +rte_rcu_qsbr_dq_create(const struct rte_rcu_qsbr_dq_parameters
> > > +*params);
> > > +
> > > +/**
> > > + * @warning
> > > + * @b EXPERIMENTAL: this API may change without prior notice
> > > + *
> > > + * Enqueue one resource to the defer queue and start the grace period.
> > > + * The resource will be freed later after at least one grace period
> > > + * is over.
> > > + *
> > > + * If the defer queue is full, it will attempt to reclaim resources.
> > > + * It will also reclaim resources at regular intervals to avoid
> > > + * the defer queue from growing too big.
> > > + *
> > > + * This API is not multi-thread safe. It is expected that the caller
> > > + * provides multi-thread safety by locking a mutex or some other means.
> > > + *
> > > + * A lock free multi-thread writer algorithm could achieve
> > > +multi-thread
> > > + * safety by creating and using one defer queue per thread.
> > > + *
> > > + * @param dq
> > > + * Defer queue to allocate an entry from.
> > > + * @param e
> > > + * Pointer to resource data to copy to the defer queue. The size of
> > > + * the data to copy is equal to the element size provided when the
> > > + * defer queue was created.
> > > + * @return
> > > + * On success - 0
> > > + * On error - 1 with rte_errno set to
> > > + * - EINVAL - NULL parameters are passed
> > > + * - ENOSPC - Defer queue is full. This condition can not happen
> > > + * if the defer queue size is equal (or larger) than the
> > > + * number of elements in the data structure.
> > > + */
> > > +__rte_experimental
> > > +int
> > > +rte_rcu_qsbr_dq_enqueue(struct rte_rcu_qsbr_dq *dq, void *e);
> > > +
> > > +/**
> > > + * @warning
> > > + * @b EXPERIMENTAL: this API may change without prior notice
> > > + *
> > > + * Reclaim resources from the defer queue.
> > > + *
> > > + * This API is not multi-thread safe. It is expected that the caller
> > > + * provides multi-thread safety by locking a mutex or some other means.
> > > + *
> > > + * A lock free multi-thread writer algorithm could achieve
> > > +multi-thread
> > > + * safety by creating and using one defer queue per thread.
> > > + *
> > > + * @param dq
> > > + * Defer queue to reclaim an entry from.
> > > + * @return
> > > + * On successful reclamation of at least 1 resource - 0
> > > + * On error - 1 with rte_errno set to
> > > + * - EINVAL - NULL parameters are passed
> > > + * - EAGAIN - None of the resources have completed at least 1 grace
> > period,
> > > + * try again.
> > > + */
> > > +__rte_experimental
> > > +int
> > > +rte_rcu_qsbr_dq_reclaim(struct rte_rcu_qsbr_dq *dq);
> > > +
> > > +/**
> > > + * @warning
> > > + * @b EXPERIMENTAL: this API may change without prior notice
> > > + *
> > > + * Delete a defer queue.
> > > + *
> > > + * It tries to reclaim all the resources on the defer queue.
> > > + * If any of the resources have not completed the grace period
> > > + * the reclamation stops and returns immediately. The rest of
> > > + * the resources are not reclaimed and the defer queue is not
> > > + * freed.
> > > + *
> > > + * @param dq
> > > + * Defer queue to delete.
> > > + * @return
> > > + * On success - 0
> > > + * On error - 1
> > > + * Possible rte_errno codes are:
> > > + * - EINVAL - NULL parameters are passed
> > > + * - EAGAIN - Some of the resources have not completed at least 1 grace
> > > + * period, try again.
> > > + */
> > > +__rte_experimental
> > > +int
> > > +rte_rcu_qsbr_dq_delete(struct rte_rcu_qsbr_dq *dq);
> > > +
> > > #ifdef __cplusplus
> > > }
> > > #endif
> > > diff --git a/lib/librte_rcu/rte_rcu_qsbr_pvt.h
> > > b/lib/librte_rcu/rte_rcu_qsbr_pvt.h
> > > new file mode 100644
> > > index 000000000..2122bc36a
> > > --- /dev/null
> > > +++ b/lib/librte_rcu/rte_rcu_qsbr_pvt.h
> > > @@ -0,0 +1,46 @@
> > > +/* SPDX-License-Identifier: BSD-3-Clause
> > > + * Copyright (c) 2019 Arm Limited
> > > + */
> > > +
> > > +#ifndef _RTE_RCU_QSBR_PVT_H_
> > > +#define _RTE_RCU_QSBR_PVT_H_
> > > +
> > > +/**
> > > + * This file is private to the RCU library. It should not be included
> > > + * by the user of this library.
> > > + */
> > > +
> > > +#ifdef __cplusplus
> > > +extern "C" {
> > > +#endif
> > > +
> > > +#include "rte_rcu_qsbr.h"
> > > +
> > > +/* RTE defer queue structure.
> > > + * This structure holds the defer queue. The defer queue is used to
> > > + * hold the deleted entries from the data structure that are not
> > > + * yet freed.
> > > + */
> > > +struct rte_rcu_qsbr_dq {
> > > + struct rte_rcu_qsbr *v; /**< RCU QSBR variable used by this queue.*/
> > > + struct rte_ring *r; /**< RCU QSBR defer queue. */
> > > + uint32_t size;
> > > + /**< Number of elements in the defer queue */
> > > + uint32_t esize;
> > > + /**< Size (in bytes) of data stored on the defer queue */
> > > + rte_rcu_qsbr_free_resource f;
> > > + /**< Function to call to free the resource. */
> > > + void *p;
> > > + /**< Pointer passed to the free function. Typically, this is the
> > > + * pointer to the data structure to which the resource to free
> > > + * belongs.
> > > + */
> > > + char e[0];
> > > + /**< Temporary storage to copy the defer queue element. */ };
> > > +
> > > +#ifdef __cplusplus
> > > +}
> > > +#endif
> > > +
> > > +#endif /* _RTE_RCU_QSBR_PVT_H_ */
> > > diff --git a/lib/librte_rcu/rte_rcu_version.map
> > > b/lib/librte_rcu/rte_rcu_version.map
> > > index f8b9ef2ab..dfac88a37 100644
> > > --- a/lib/librte_rcu/rte_rcu_version.map
> > > +++ b/lib/librte_rcu/rte_rcu_version.map
> > > @@ -8,6 +8,10 @@ EXPERIMENTAL {
> > > rte_rcu_qsbr_synchronize;
> > > rte_rcu_qsbr_thread_register;
> > > rte_rcu_qsbr_thread_unregister;
> > > + rte_rcu_qsbr_dq_create;
> > > + rte_rcu_qsbr_dq_enqueue;
> > > + rte_rcu_qsbr_dq_reclaim;
> > > + rte_rcu_qsbr_dq_delete;
> > >
> > > local: *;
> > > };
> > > diff --git a/lib/meson.build b/lib/meson.build index
> > > e5ff83893..0e1be8407 100644
> > > --- a/lib/meson.build
> > > +++ b/lib/meson.build
> > > @@ -11,7 +11,9 @@
> > > libraries = [
> > > 'kvargs', # eal depends on kvargs
> > > 'eal', # everything depends on eal
> > > - 'ring', 'mempool', 'mbuf', 'net', 'meter', 'ethdev', 'pci', # core
> > > + 'ring',
> > > + 'rcu', # rcu depends on ring
> > > + 'mempool', 'mbuf', 'net', 'meter', 'ethdev', 'pci', # core
> > > 'cmdline',
> > > 'metrics', # bitrate/latency stats depends on this
> > > 'hash', # efd depends on this
> > > @@ -22,7 +24,7 @@ libraries = [
> > > 'gro', 'gso', 'ip_frag', 'jobstats',
> > > 'kni', 'latencystats', 'lpm', 'member',
> > > 'power', 'pdump', 'rawdev',
> > > - 'rcu', 'reorder', 'sched', 'security', 'stack', 'vhost',
> > > + 'reorder', 'sched', 'security', 'stack', 'vhost',
> > > # ipsec lib depends on net, crypto and security
> > > 'ipsec',
> > > # add pkt framework libs which use other libs from above
> > > --
> > > 2.17.1
