size_trte_rcu_qsbr_get_memsize(uint32_tmax_threads)
Return the size of the memory occupied by a Quiescent State variable.
Parametersmax_threads Maximum number of threads reporting quiescent state on this variable.
Returns
On success - size of memory in bytes required for this QS variable. On error - 1 with error code set
in rte_errno. Possible rte_errno codes are:
• EINVAL - max_threads is 0
intrte_rcu_qsbr_init(structrte_rcu_qsbr*v,uint32_tmax_threads)
Initialize a Quiescent State (QS) variable.
Parametersv QS variable
max_threads Maximum number of threads reporting quiescent state on this variable. This should be the
same value as passed to rte_rcu_qsbr_get_memsize.
Returns
On success - 0 On error - 1 with error code set in rte_errno. Possible rte_errno codes are:
• EINVAL - max_threads is 0 or 'v' is NULL.
intrte_rcu_qsbr_thread_register(structrte_rcu_qsbr*v,unsignedintthread_id)
Register a reader thread to report its quiescent state on a QS variable.
This is implemented as a lock-free function. It is multi-thread safe. Any reader thread that wants to
report its quiescent state must call this API. This can be called during initialization or as part of the
packet processing loop.
Note that rte_rcu_qsbr_thread_online must be called before the thread updates its quiescent state using
rte_rcu_qsbr_quiescent.
Parametersv QS variable
thread_id Reader thread with this thread ID will report its quiescent state on the QS variable.
thread_id is a value between 0 and (max_threads - 1). 'max_threads' is the parameter passed in
'rte_rcu_qsbr_init' API.
intrte_rcu_qsbr_thread_unregister(structrte_rcu_qsbr*v,unsignedintthread_id)
Remove a reader thread, from the list of threads reporting their quiescent state on a QS variable.
This is implemented as a lock-free function. It is multi-thread safe. This API can be called from the
reader threads during shutdown. Ongoing quiescent state queries will stop waiting for the status from
this unregistered reader thread.
Parametersv QS variable
thread_id Reader thread with this thread ID will stop reporting its quiescent state on the QS
variable.
static__rte_always_inlinevoidrte_rcu_qsbr_thread_online(structrte_rcu_qsbr*v,unsignedintthread_id)[static]
Add a registered reader thread, to the list of threads reporting their quiescent state on a QS variable.
This is implemented as a lock-free function. It is multi-thread safe.
Any registered reader thread that wants to report its quiescent state must call this API before calling
rte_rcu_qsbr_quiescent. This can be called during initialization or as part of the packet processing
loop.
The reader thread must call rte_rcu_qsbr_thread_offline API, before calling any functions that block, to
ensure that rte_rcu_qsbr_check API does not wait indefinitely for the reader thread to update its QS.
The reader thread must call rte_rcu_thread_online API, after the blocking function call returns, to
ensure that rte_rcu_qsbr_check API waits for the reader thread to update its quiescent state.
Parametersv QS variable
thread_id Reader thread with this thread ID will report its quiescent state on the QS variable.
Definition at line 296 of file rte_rcu_qsbr.h.
static__rte_always_inlinevoidrte_rcu_qsbr_thread_offline(structrte_rcu_qsbr*v,unsignedintthread_id)[static]
Remove a registered reader thread from the list of threads reporting their quiescent state on a QS
variable.
This is implemented as a lock-free function. It is multi-thread safe.
This can be called during initialization or as part of the packet processing loop.
The reader thread must call rte_rcu_qsbr_thread_offline API, before calling any functions that block, to
ensure that rte_rcu_qsbr_check API does not wait indefinitely for the reader thread to update its QS.
Parametersv QS variable
thread_id rte_rcu_qsbr_check API will not wait for the reader thread with this thread ID to report
its quiescent state on the QS variable.
Definition at line 349 of file rte_rcu_qsbr.h.
static__rte_always_inlinevoidrte_rcu_qsbr_lock(__rte_unusedstructrte_rcu_qsbr*v,__rte_unusedunsignedintthread_id)[static]
Acquire a lock for accessing a shared data structure.
This is implemented as a lock-free function. It is multi-thread safe.
This API is provided to aid debugging. This should be called before accessing a shared data structure.
When RTE_LIBRTE_RCU_DEBUG is enabled a lock counter is incremented. Similarly rte_rcu_qsbr_unlock will
decrement the counter. When the rte_rcu_qsbr_check API will verify that this counter is 0.
When RTE_LIBRTE_RCU_DEBUG is disabled, this API will do nothing.
Parametersv QS variable
thread_id Reader thread id
Definition at line 386 of file rte_rcu_qsbr.h.
static__rte_always_inlinevoidrte_rcu_qsbr_unlock(__rte_unusedstructrte_rcu_qsbr*v,__rte_unusedunsignedintthread_id)[static]
Release a lock after accessing a shared data structure.
This is implemented as a lock-free function. It is multi-thread safe.
This API is provided to aid debugging. This should be called after accessing a shared data structure.
When RTE_LIBRTE_RCU_DEBUG is enabled, rte_rcu_qsbr_unlock will decrement a lock counter.
rte_rcu_qsbr_check API will verify that this counter is 0.
When RTE_LIBRTE_RCU_DEBUG is disabled, this API will do nothing.
Parametersv QS variable
thread_id Reader thread id
Definition at line 419 of file rte_rcu_qsbr.h.
static__rte_always_inlineuint64_trte_rcu_qsbr_start(structrte_rcu_qsbr*v)[static]
Ask the reader threads to report the quiescent state status.
This is implemented as a lock-free function. It is multi-thread safe and can be called from worker
threads.
Parametersv QS variable
Returns
• This is the token for this call of the API. This should be passed to rte_rcu_qsbr_check API.
Definition at line 449 of file rte_rcu_qsbr.h.
static__rte_always_inlinevoidrte_rcu_qsbr_quiescent(structrte_rcu_qsbr*v,unsignedintthread_id)[static]
Update quiescent state for a reader thread.
This is implemented as a lock-free function. It is multi-thread safe. All the reader threads registered
to report their quiescent state on the QS variable must call this API.
Parametersv QS variable
thread_id Update the quiescent state for the reader with this thread ID.
Definition at line 478 of file rte_rcu_qsbr.h.
static__rte_always_inlineintrte_rcu_qsbr_check(structrte_rcu_qsbr*v,uint64_tt,boolwait)[static]
Checks if all the reader threads have entered the quiescent state referenced by token.
This is implemented as a lock-free function. It is multi-thread safe and can be called from the worker
threads as well.
If this API is called with 'wait' set to true, the following factors must be considered:
1) If the calling thread is also reporting the status on the same QS variable, it must update the
quiescent state status, before calling this API.
2) In addition, while calling from multiple threads, only one of those threads can be reporting the
quiescent state status on a given QS variable.
Parametersv QS variable
t Token returned by rte_rcu_qsbr_start API
wait If true, block till all the reader threads have completed entering the quiescent state
referenced by token 't'.
Returns
• 0 if all reader threads have NOT passed through specified number of quiescent states.
• 1 if all reader threads have passed through specified number of quiescent states.
Definition at line 665 of file rte_rcu_qsbr.h.
voidrte_rcu_qsbr_synchronize(structrte_rcu_qsbr*v,unsignedintthread_id)
Wait till the reader threads have entered quiescent state.
This is implemented as a lock-free function. It is multi-thread safe. This API can be thought of as a
wrapper around rte_rcu_qsbr_start and rte_rcu_qsbr_check APIs.
If this API is called from multiple threads, only one of those threads can be reporting the quiescent
state status on a given QS variable.
Parametersv QS variable
thread_id Thread ID of the caller if it is registered to report quiescent state on this QS variable
(i.e. the calling thread is also part of the readside critical section). If not, pass
RTE_QSBR_THRID_INVALID.
intrte_rcu_qsbr_dump(FILE*f,structrte_rcu_qsbr*v)
Dump the details of a single QS variables to a file.
It is NOT multi-thread safe.
Parametersf A pointer to a file for output
v QS variable
Returns
On success - 0 On error - 1 with error code set in rte_errno. Possible rte_errno codes are:
• EINVAL - NULL parameters are passed
structrte_rcu_qsbr_dq*rte_rcu_qsbr_dq_create(conststructrte_rcu_qsbr_dq_parameters*params)
Create a queue used to store the data structure elements that can be freed later. This queue is referred
to as 'defer queue'.
Parametersparams Parameters to create a defer queue.
Returns
On success - Valid pointer to defer queue On error - NULL Possible rte_errno codes are:
• EINVAL - NULL parameters are passed
• ENOMEM - Not enough memory
intrte_rcu_qsbr_dq_enqueue(structrte_rcu_qsbr_dq*dq,void*e)
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.
Multi-thread safety is provided as the defer queue configuration. When multi-thread safety is requested,
it is possible that the resources are not stored in their order of deletion. This results in resources
being held in the defer queue longer than they should.
Parametersdq Defer queue to allocate an entry from.
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.
Returns
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.
intrte_rcu_qsbr_dq_reclaim(structrte_rcu_qsbr_dq*dq,unsignedintn,unsignedint*freed,unsignedint*pending,unsignedint*available)
Free resources from the defer queue.
This API is multi-thread safe.
Parametersdq Defer queue to free an entry from.
n Maximum number of resources to free.
freed Number of resources that were freed.
pending Number of resources pending on the defer queue. This number might not be accurate if multi-
thread safety is configured.
available Number of resources that can be added to the defer queue. This number might not be accurate
if multi-thread safety is configured.
Returns
On successful reclamation of at least 1 resource - 0 On error - 1 with rte_errno set to
• EINVAL - NULL parameters are passed
intrte_rcu_qsbr_dq_delete(structrte_rcu_qsbr_dq*dq)
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.
Parametersdq Defer queue to delete.
Returns
On success - 0 On error - 1 Possible rte_errno codes are:
• EAGAIN - Some of the resources have not completed at least 1 grace period, try again.
Install Now
PNG Icons
SVG Icons