rte_ring_hts_elem_pvt.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright (c) 2010-2020 Intel Corporation
 * Copyright (c) 2007-2009 Kip Macy kmacy@freebsd.org
 * All rights reserved.
 * Derived from FreeBSD's bufring.h
 * Used as BSD-3 Licensed with permission from Kip Macy.
 */
 
#ifndef _RTE_RING_HTS_ELEM_PVT_H_
#define _RTE_RING_HTS_ELEM_PVT_H_
 
#include <rte_stdatomic.h>
 
static __rte_always_inline void
__rte_ring_hts_update_tail(struct rte_ring_hts_headtail *ht, uint32_t old_tail,
    uint32_t num, uint32_t enqueue)
{
    uint32_t tail;
 
    RTE_SET_USED(enqueue);
 
    tail = old_tail + num;
 
    /*
     * R0: Release the tail update. Establishes a synchronization edge with
     * the load-acquire at A1. This release ensures that all updates to *ht
     * and the ring array made by this thread become visible to the opposing
     * thread once the tail value written here is observed.
     */
    rte_atomic_store_explicit(&ht->ht.pos.tail, tail, rte_memory_order_release);
}
 
static __rte_always_inline union __rte_ring_hts_pos
__rte_ring_hts_head_wait(const struct rte_ring_hts_headtail *ht,
             rte_memory_order memorder)
{
    union __rte_ring_hts_pos p;
    p.raw = rte_atomic_load_explicit(&ht->ht.raw, memorder);
 
    while (p.pos.head != p.pos.tail) {
        rte_pause();
        p.raw = rte_atomic_load_explicit(&ht->ht.raw, memorder);
    }
 
    return p;
}
 
static __rte_always_inline uint32_t
__rte_ring_hts_move_head(struct rte_ring_hts_headtail *d,
    const struct rte_ring_headtail *s, uint32_t capacity, unsigned int num,
    enum rte_ring_queue_behavior behavior, uint32_t *old_head,
    uint32_t *entries)
{
    uint32_t n, stail;
    union __rte_ring_hts_pos np, op;
 
    do {
        /* Reset n to the initial burst count */
        n = num;
 
        /*
         * wait for tail to be equal to head,
         * make sure that we read prod head/tail *before*
         * reading cons tail.
         */
        /*
         * A0: Synchronizes with the CAS at R1.
         * Establishes a happens-before relationship with a thread of the same
         * type that released the ht.raw, ensuring this thread observes all of
         * its memory effects needed to maintain a safe partial order.
         */
        op = __rte_ring_hts_head_wait(d, rte_memory_order_acquire);
 
        /*
         * A1: Establish a synchronizes-with edge using a store-release at R0.
         * This ensures that all memory effects from the preceding opposing
         * thread are observed.
         */
        stail = rte_atomic_load_explicit(&s->tail, rte_memory_order_acquire);
 
        /*
         *  The subtraction is done between two unsigned 32bits value
         * (the result is always modulo 32 bits even if we have
         * *old_head > cons_tail). So 'entries' is always between 0
         * and capacity (which is < size).
         */
        *entries = capacity + stail - op.pos.head;
 
        /* check that we have enough room in ring */
        if (unlikely(n > *entries))
            n = (behavior == RTE_RING_QUEUE_FIXED) ?
                    0 : *entries;
 
        if (n == 0)
            break;
 
        np.pos.tail = op.pos.tail;
        np.pos.head = op.pos.head + n;
 
    /*
     * R1: Establishes a synchronizes-with edge with the load-acquire
     * of ht.raw at A0. This makes sure that the store-release to the
     * tail by this thread, if it was of the opposite type, becomes
     * visible to another thread of the current type. That thread will
     * then observe the updates in the same order, keeping a safe
     * partial order.
     */
    } while (rte_atomic_compare_exchange_strong_explicit(&d->ht.raw,
            (uint64_t *)(uintptr_t)&op.raw, np.raw,
            rte_memory_order_release,
            rte_memory_order_relaxed) == 0);
 
    *old_head = op.pos.head;
    return n;
}
static __rte_always_inline unsigned int
__rte_ring_hts_move_prod_head(struct rte_ring *r, unsigned int num,
    enum rte_ring_queue_behavior behavior, uint32_t *old_head,
    uint32_t *free_entries)
{
    return __rte_ring_hts_move_head(&r->hts_prod, &r->cons,
            r->capacity, num, behavior, old_head, free_entries);
}
 
static __rte_always_inline unsigned int
__rte_ring_hts_move_cons_head(struct rte_ring *r, unsigned int num,
    enum rte_ring_queue_behavior behavior, uint32_t *old_head,
    uint32_t *entries)
{
    return __rte_ring_hts_move_head(&r->hts_cons, &r->prod,
            0, num, behavior, old_head, entries);
}
 
static __rte_always_inline unsigned int
__rte_ring_do_hts_enqueue_elem(struct rte_ring *r, const void *obj_table,
    uint32_t esize, uint32_t n, enum rte_ring_queue_behavior behavior,
    uint32_t *free_space)
{
    uint32_t free, head;
 
    n =  __rte_ring_hts_move_prod_head(r, n, behavior, &head, &free);
 
    if (n != 0) {
        __rte_ring_enqueue_elems(r, head, obj_table, esize, n);
        __rte_ring_hts_update_tail(&r->hts_prod, head, n, 1);
    }
 
    if (free_space != NULL)
        *free_space = free - n;
    return n;
}
 
static __rte_always_inline unsigned int
__rte_ring_do_hts_dequeue_elem(struct rte_ring *r, void *obj_table,
    uint32_t esize, uint32_t n, enum rte_ring_queue_behavior behavior,
    uint32_t *available)
{
    uint32_t entries, head;
 
    n = __rte_ring_hts_move_cons_head(r, n, behavior, &head, &entries);
 
    if (n != 0) {
        __rte_ring_dequeue_elems(r, head, obj_table, esize, n);
        __rte_ring_hts_update_tail(&r->hts_cons, head, n, 0);
    }
 
    if (available != NULL)
        *available = entries - n;
    return n;
}
 
#endif /* _RTE_RING_HTS_ELEM_PVT_H_ */