rte_ring_gcc_pvt.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright (c) 2010-2017 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_GCC_PVT_H_
#define _RTE_RING_GCC_PVT_H_
 
static __rte_always_inline unsigned int
__rte_ring_headtail_move_head_st(struct rte_ring_headtail *d,
        const struct rte_ring_headtail *s, uint32_t capacity,
        unsigned int n,
        enum rte_ring_queue_behavior behavior,
        uint32_t *old_head, uint32_t *new_head, uint32_t *entries)
{
 
    *old_head = d->head;
 
    /* add rmb barrier to avoid load/load reorder in weak
     * memory model. It is noop on x86
     */
    rte_smp_rmb();
 
    /*
     *  The subtraction is done between two unsigned 32bits value
     * (the result is always modulo 32 bits even if we have
     * *old_head > s->tail). So 'entries' is always between 0
     * and capacity (which is < size).
     */
    *entries = capacity + s->tail - *old_head;
 
    /* check that we have enough room in ring */
    if (unlikely(n > *entries))
        n = (behavior == RTE_RING_QUEUE_FIXED) ? 0 : *entries;
 
    if (n == 0)
        return 0;
 
    *new_head = *old_head + n;
    d->head = *new_head;
    return n;
}
 
static __rte_always_inline unsigned int
__rte_ring_headtail_move_head_mt(struct rte_ring_headtail *d,
        const struct rte_ring_headtail *s, uint32_t capacity,
        unsigned int n, enum rte_ring_queue_behavior behavior,
        uint32_t *old_head, uint32_t *new_head, uint32_t *entries)
{
    unsigned int max = n;
    bool success;
 
    do {
        /* Reset n to the initial burst count */
        n = max;
 
        *old_head = d->head;
 
        /* add fence to avoid load/load reorder in weak
         * memory model. It is noop on x86
         */
        __atomic_thread_fence(__ATOMIC_ACQUIRE);
 
        /*
         *  The subtraction is done between two unsigned 32bits value
         * (the result is always modulo 32 bits even if we have
         * *old_head > s->tail). So 'entries' is always between 0
         * and capacity (which is < size).
         */
        *entries = (capacity + s->tail - *old_head);
 
        /* check that we have enough room in ring */
        if (unlikely(n > *entries))
            n = (behavior == RTE_RING_QUEUE_FIXED) ?
                    0 : *entries;
 
        if (n == 0)
            return 0;
 
        *new_head = *old_head + n;
 
        success = __sync_bool_compare_and_swap(
                (uint32_t *)(uintptr_t)&d->head,
                *old_head, *new_head);
    } while (unlikely(!success));
 
    return n;
}
 
#endif /* _RTE_RING_GCC_PVT_H_ */