cne_rwlock.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2010-2022 Intel Corporation
 */
 
#ifndef _CNE_RWLOCK_H_
#define _CNE_RWLOCK_H_
 
#include <cne_branch_prediction.h>
#include <cne_spinlock.h>
#include <cne_common.h>
#include <cne_pause.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct {
    volatile int32_t cnt; 
} cne_rwlock_t;
 
#define CNE_RWLOCK_INITIALIZER \
    {                          \
        0                      \
    }
 
static inline void
cne_rwlock_init(cne_rwlock_t *rwl)
{
    rwl->cnt = 0;
}
 
static inline void
cne_rwlock_read_lock(cne_rwlock_t *rwl)
{
    int32_t x;
    int success = 0;
 
    while (success == 0) {
        x = __atomic_load_n(&rwl->cnt, __ATOMIC_RELAXED);
        /* write lock is held */
        if (x < 0) {
            cne_pause();
            continue;
        }
        success = __atomic_compare_exchange_n(&rwl->cnt, &x, x + 1, 1, __ATOMIC_ACQUIRE,
                                              __ATOMIC_RELAXED);
    }
}
 
static inline int
cne_rwlock_read_trylock(cne_rwlock_t *rwl)
{
    int32_t x;
    int success = 0;
 
    while (success == 0) {
        x = __atomic_load_n(&rwl->cnt, __ATOMIC_RELAXED);
        /* write lock is held */
        if (x < 0)
            return -EBUSY;
        success = __atomic_compare_exchange_n(&rwl->cnt, &x, x + 1, 1, __ATOMIC_ACQUIRE,
                                              __ATOMIC_RELAXED);
    }
 
    return 0;
}
 
static inline void
cne_rwlock_read_unlock(cne_rwlock_t *rwl)
{
    __atomic_fetch_sub(&rwl->cnt, 1, __ATOMIC_RELEASE);
}
 
static inline int
cne_rwlock_write_trylock(cne_rwlock_t *rwl)
{
    int32_t x;
 
    x = __atomic_load_n(&rwl->cnt, __ATOMIC_RELAXED);
    if (x != 0 ||
        __atomic_compare_exchange_n(&rwl->cnt, &x, -1, 1, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED) == 0)
        return -EBUSY;
 
    return 0;
}
 
static inline void
cne_rwlock_write_lock(cne_rwlock_t *rwl)
{
    int32_t x;
    int success = 0;
 
    while (success == 0) {
        x = __atomic_load_n(&rwl->cnt, __ATOMIC_RELAXED);
        /* a lock is held */
        if (x != 0) {
            cne_pause();
            continue;
        }
        success =
            __atomic_compare_exchange_n(&rwl->cnt, &x, -1, 1, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED);
    }
}
 
static inline void
cne_rwlock_write_unlock(cne_rwlock_t *rwl)
{
    __atomic_store_n(&rwl->cnt, 0, __ATOMIC_RELEASE);
}
 
static inline void
cne_rwlock_read_lock_tm(cne_rwlock_t *rwl)
{
    if (likely(cne_try_tm(&rwl->cnt)))
        return;
    cne_rwlock_read_lock(rwl);
}
 
static inline void
cne_rwlock_read_unlock_tm(cne_rwlock_t *rwl)
{
    if (unlikely(rwl->cnt))
        cne_rwlock_read_unlock(rwl);
    else
        cne_xend();
}
 
static inline void
cne_rwlock_write_lock_tm(cne_rwlock_t *rwl)
{
    if (likely(cne_try_tm(&rwl->cnt)))
        return;
    cne_rwlock_write_lock(rwl);
}
 
static inline void
cne_rwlock_write_unlock_tm(cne_rwlock_t *rwl)
{
    if (unlikely(rwl->cnt))
        cne_rwlock_write_unlock(rwl);
    else
        cne_xend();
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* _CNE_RWLOCK_H_ */