cib.h

Go to the documentation of this file.

/*
 * Copyright (C) 2016 Kaspar Schleiser <kaspar@schleiser.de>
 *               2013 Freie Universität Berlin
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */
 
#pragma once
 
#include "assert.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct {
    unsigned int read_count;    
    unsigned int write_count;   
    unsigned int mask;          
} cib_t;
typedef struct  {…};
 
#define CIB_INIT(SIZE) { 0, 0, (SIZE)-1 }
 
static inline void cib_init(cib_t *__restrict cib, unsigned int size)
{
    /* check if size is a power of 2 by comparing it to its complement */
    assert(!(size & (size - 1)));
 
    cib_t c = CIB_INIT(size);
 
    *cib = c;
}
static inline void cib_init(cib_t *__restrict cib, unsigned int size) {…}
 
static inline unsigned int cib_size(const cib_t *cib)
{
    return cib->mask + 1;
}
static inline unsigned int cib_size(const cib_t *cib) {…}
 
static inline unsigned int cib_avail(const cib_t *cib)
{
    return cib->write_count - cib->read_count;
}
static inline unsigned int cib_avail(const cib_t *cib) {…}
 
static inline unsigned int cib_full(const cib_t *cib)
{
    return ((int)cib_avail(cib)) > ((int)cib->mask);
}
static inline unsigned int cib_full(const cib_t *cib) {…}
 
static inline int cib_get(cib_t *__restrict cib)
{
    if (cib_avail(cib)) {
        return (int)(cib->read_count++ & cib->mask);
    }
 
    return -1;
}
static inline int cib_get(cib_t *__restrict cib) {…}
 
static inline int cib_peek_at_unsafe(const cib_t *__restrict cib, unsigned offset)
{
    return (cib->read_count + offset) & cib->mask;
}
static inline int cib_peek_at_unsafe(const cib_t *__restrict cib, unsigned offset) {…}
 
static inline int cib_peek_at(const cib_t *__restrict cib, unsigned offset)
{
    if (offset < cib_avail(cib)) {
        return cib_peek_at_unsafe(cib, offset);
    }
 
    return -1;
}
static inline int cib_peek_at(const cib_t *__restrict cib, unsigned offset) {…}
 
static inline int cib_peek_unsafe(const cib_t *__restrict cib)
{
    return cib_peek_at_unsafe(cib, 0);
}
static inline int cib_peek_unsafe(const cib_t *__restrict cib) {…}
 
static inline int cib_peek(const cib_t *__restrict cib)
{
    return cib_peek_at(cib, 0);
}
static inline int cib_peek(const cib_t *__restrict cib) {…}
 
static inline int cib_get_unsafe(cib_t *cib)
{
    return (int)(cib->read_count++ & cib->mask);
}
static inline int cib_get_unsafe(cib_t *cib) {…}
 
static inline int cib_put(cib_t *__restrict cib)
{
    unsigned int avail = cib_avail(cib);
 
    /* We use a signed compare, because the mask is -1u for an empty CIB. */
    if ((int)avail <= (int)cib->mask) {
        return (int)(cib->write_count++ & cib->mask);
    }
 
    return -1;
}
static inline int cib_put(cib_t *__restrict cib) {…}
 
static inline int cib_put_unsafe(cib_t *cib)
{
    return (int)(cib->write_count++ & cib->mask);
}
static inline int cib_put_unsafe(cib_t *cib) {…}
 
#ifdef __cplusplus
}
#endif