storage.hh

// -*- c-basic-offset: 4 -*-
#ifndef CLICK_STORAGE_HH
#define CLICK_STORAGE_HH
#include <click/machine.hh>
#include <click/atomic.hh>
CLICK_DECLS
class Packet;
 
class Storage { public:
 
    typedef uint32_t index_type;
    typedef int32_t signed_index_type;
    static const index_type invalid_index = (index_type) -1;
 
    Storage()                           : _head(0), _tail(0) { }
 
    operator bool() const               { return _head != _tail; }
    bool empty() const                  { return _head == _tail; }
    int size() const;
    int size(index_type head, index_type tail) const;
    int capacity() const                { return _capacity; }
 
    index_type head() const             { return _head; }
    index_type tail() const             { return _tail; }
 
    index_type next_i(index_type i) const {
        return (i!=_capacity ? i+1 : 0);
    }
    index_type prev_i(index_type i) const {
        return (i!=0 ? i-1 : _capacity);
    }
 
    // to be used with care
    void set_capacity(index_type c)     { _capacity = c; }
    inline void set_head(index_type h); // acquire barrier (read pkt)
    inline void set_tail(index_type t); // release barrier (write pkt)
    inline void set_head_release(index_type h); // release barrier (LIFO)
    inline void set_tail_acquire(index_type t); // acquire barrier (LIFO)
    inline index_type reserve_tail_atomic();
 
    static inline void packet_memory_barrier(Packet* volatile& packet,
                                             volatile index_type& index)
        __attribute__((deprecated));
    inline void packet_memory_barrier(Packet* volatile& packet)
        __attribute__((deprecated));
 
  protected:
    index_type _capacity;
 
  private:
    volatile index_type _head;
    volatile index_type _tail;
 
};
 
inline int
Storage::size(index_type head, index_type tail) const
{
    index_type x = tail - head;
    return (signed_index_type(x) >= 0 ? x : _capacity + x + 1);
}
 
inline int
Storage::size() const
{
    return size(_head, _tail);
}
 
inline void
Storage::set_head(index_type h)
{
    click_read_fence();
    _head = h;
}
 
inline void
Storage::set_tail(index_type t)
{
    click_write_fence();
    _tail = t;
}
 
inline void
Storage::set_head_release(index_type h)
{
    click_write_fence();
    _head = h;
}
 
inline void
Storage::set_tail_acquire(index_type t)
{
    click_read_fence();
    _tail = t;
}
 
inline Storage::index_type
Storage::reserve_tail_atomic()
{
    index_type t, nt;
    do {
        t = _tail;
        nt = next_i(t);
        if (nt == _head)
            return invalid_index;
#if ! CLICK_ATOMIC_COMPARE_SWAP
    } while (!atomic_uint32_t::compare_and_swap(_tail, t, nt));
#else
    } while (atomic_uint32_t::compare_swap(_tail, t, nt) != t);
#endif
    return t;
}
 
inline void
Storage::packet_memory_barrier(Packet* volatile& packet, volatile index_type& index)
{
    __asm__ volatile("" : : "m" (packet), "m" (index));
}
 
inline void
Storage::packet_memory_barrier(Packet * volatile &packet)
{
    __asm__ volatile("" : : "m" (packet), "m" (_head), "m" (_tail));
}
 
CLICK_ENDDECLS
#endif