notifier.hh

Go to the documentation of this file.

// -*- c-basic-offset: 4; related-file-name: "../../lib/notifier.cc" -*-
#ifndef CLICK_NOTIFIER_HH
#define CLICK_NOTIFIER_HH
#include <click/task.hh>
#include <click/atomic.hh>
#include <click/algorithm.hh>
#if HAVE_CXX_PRAGMA_INTERFACE
# pragma interface "click/notifier.hh"
#endif
CLICK_DECLS
 
class NotifierSignal {
  public:
    typedef bool (NotifierSignal::*unspecified_bool_type)() const;
 
    inline NotifierSignal();
    inline NotifierSignal(atomic_uint32_t* value, uint32_t mask);
    inline NotifierSignal(const NotifierSignal& x);
    inline ~NotifierSignal();
 
    static inline NotifierSignal idle_signal();
    static inline NotifierSignal busy_signal();
    static inline NotifierSignal overderived_signal();
    static inline NotifierSignal uninitialized_signal();
 
    inline bool active() const;
    inline bool safe_active() const;
    inline operator unspecified_bool_type() const;
 
    inline bool set_active(bool active);
 
    inline bool idle() const;
    inline bool busy() const;
    inline bool overderived() const;
    inline bool initialized() const;
 
    friend bool operator==(const NotifierSignal &a, const NotifierSignal &b);
    friend bool operator!=(const NotifierSignal &a, const NotifierSignal &b);
 
    NotifierSignal& operator=(const NotifierSignal& x);
    NotifierSignal& operator+=(const NotifierSignal& x);
    friend NotifierSignal operator+(NotifierSignal a, const NotifierSignal &b);
 
    inline void swap(NotifierSignal& x);
 
    String unparse(Router *router) const;
 
    static void static_initialize();
 
  private:
    struct vmpair {
        atomic_uint32_t *value;
        uint32_t mask;
    };
    union vmvalue {
        atomic_uint32_t *v1;
        vmpair *vm;
    };
 
    vmvalue _v;
    uint32_t _mask;
 
    enum {
        true_mask = 1, false_mask = 2, overderived_mask = 4,
        uninitialized_mask = 8
    };
    static atomic_uint32_t static_value;
 
    void hard_assign_vm(const NotifierSignal &x);
    void hard_derive_one(atomic_uint32_t *value, uint32_t mask);
    static bool hard_equals(const vmpair *a, const vmpair *b);
};
 
class Notifier { public:
 
    enum SearchOp { SEARCH_STOP = 0, SEARCH_CONTINUE, SEARCH_CONTINUE_WAKE };
    typedef void (*callback_type)(void *, Notifier *);
 
    inline Notifier(SearchOp op = SEARCH_STOP);
    inline Notifier(const NotifierSignal &signal, SearchOp op = SEARCH_STOP);
    virtual ~Notifier();
 
    inline bool initialized() const {
        return _signal.initialized();
    }
 
    int initialize(const char *name, Router *router);
 
    inline const NotifierSignal &signal() const;
    inline SearchOp search_op() const;
 
    inline bool active() const;
    inline bool safe_active() const;
 
    inline bool set_active(bool active);
    inline void wake();
    inline void sleep();
 
    virtual int add_activate_callback(callback_type f, void *user_data);
    virtual void remove_activate_callback(callback_type f, void *user_data);
    inline int add_listener(Task *task);
    inline void remove_listener(Task *task);
    inline int add_dependent_signal(NotifierSignal *signal);
    inline void remove_dependent_signal(NotifierSignal *signal);
 
    static const char EMPTY_NOTIFIER[];
    static const char FULL_NOTIFIER[];
 
    static inline NotifierSignal upstream_empty_signal(Element *e, int port);
    static inline NotifierSignal upstream_empty_signal(Element *e, int port, Task *task);
    static inline NotifierSignal upstream_empty_signal(Element *e, int port, Notifier *dependent_notifier);
    static inline NotifierSignal upstream_signal(Element *e, int port, Task *task, const char* signal);
    static inline NotifierSignal upstream_empty_signal(Element *e, int port, callback_type f, void *user_data);
    static NotifierSignal upstream_signal(Element *e, int port, callback_type f, void *user_data, const char* signal);
 
    static inline NotifierSignal downstream_full_signal(Element *e, int port);
    static inline NotifierSignal downstream_full_signal(Element *e, int port, Task *task);
    static inline NotifierSignal downstream_full_signal(Element *e, int port, Notifier *dependent_notifier);
    static NotifierSignal downstream_full_signal(Element *e, int port, callback_type f, void *user_data);
 
    static inline NotifierSignal upstream_empty_signal(Element *e, int port, int) CLICK_DEPRECATED;
    static inline NotifierSignal upstream_empty_signal(Element *e, int port, int, Notifier *) CLICK_DEPRECATED;
    static inline NotifierSignal downstream_full_signal(Element *e, int port, int) CLICK_DEPRECATED;
    static inline NotifierSignal downstream_full_signal(Element *e, int port, int, Notifier *) CLICK_DEPRECATED;
 
  private:
 
    NotifierSignal _signal;
    SearchOp _search_op;
 
    static void dependent_signal_callback(void *, Notifier *);
 
};
 
class ActiveNotifier : public Notifier { public:
 
    ActiveNotifier(SearchOp op = SEARCH_STOP);
    ~ActiveNotifier();
 
    int add_activate_callback(callback_type f, void *v);
    void remove_activate_callback(callback_type f, void *v);
    void listeners(Vector<Task*> &v) const CLICK_DEPRECATED;
 
    inline void set_active(bool active, bool schedule = true);
    inline void wake();
    inline void sleep();
 
#if CLICK_DEBUG_SCHEDULING
    String unparse(Router *router) const;
#endif
 
  private:
 
    typedef union {
        Task *t;
        callback_type f;
        void *v;
        uintptr_t p;
    } task_or_signal_t;
 
    Task* _listener1;
    task_or_signal_t* _listeners;
 
    int listener_add(callback_type f, void *v);
    int listener_remove(callback_type f, void *v);
 
    ActiveNotifier(const ActiveNotifier&); // does not exist
    ActiveNotifier& operator=(const ActiveNotifier&); // does not exist
 
};
 
 
inline NotifierSignal::NotifierSignal()
    : _mask(true_mask) {
    _v.v1 = &static_value;
}
 
inline NotifierSignal::NotifierSignal(atomic_uint32_t* value, uint32_t mask)
    : _mask(mask) {
    _v.v1 = value;
}
 
inline NotifierSignal::NotifierSignal(const NotifierSignal& x)
    : _mask(x._mask) {
    if (likely(_mask))
        _v.v1 = x._v.v1;
    else
        hard_assign_vm(x);
}
 
inline NotifierSignal::~NotifierSignal() {
    if (unlikely(_mask == 0))
        delete[] _v.vm;
}
 
inline NotifierSignal NotifierSignal::idle_signal() {
    return NotifierSignal(&static_value, false_mask);
}
 
inline NotifierSignal NotifierSignal::busy_signal() {
    return NotifierSignal(&static_value, true_mask);
}
 
inline NotifierSignal NotifierSignal::overderived_signal() {
    return NotifierSignal(&static_value, overderived_mask | true_mask);
}
 
inline NotifierSignal NotifierSignal::uninitialized_signal() {
    return NotifierSignal(&static_value, uninitialized_mask);
}
 
inline bool NotifierSignal::active() const {
    // 2012.May.16 This fence is necessary; consider, for example,
    // InfiniteSource's checking of nonfull notifiers.
    click_fence();
    return safe_active();
}
 
inline bool NotifierSignal::safe_active() const {
    if (likely(_mask))
        return (*_v.v1 & _mask) != 0;
    else {
        for (vmpair *vm = _v.vm; vm->mask; ++vm)
            if ((*vm->value & vm->mask) != 0)
                return true;
        return false;
    }
}
 
inline NotifierSignal::operator unspecified_bool_type() const {
    return active() ? &NotifierSignal::active : 0;
}
 
inline bool NotifierSignal::idle() const {
    return (_mask == false_mask && _v.v1 == &static_value);
}
 
inline bool NotifierSignal::busy() const {
    return ((_mask & true_mask) && _v.v1 == &static_value);
}
 
inline bool NotifierSignal::overderived() const {
    return ((_mask & overderived_mask) && _v.v1 == &static_value);
}
 
inline bool NotifierSignal::initialized() const {
    return (!(_mask & uninitialized_mask) || _v.v1 != &static_value);
}
 
inline bool NotifierSignal::set_active(bool active) {
    assert(_v.v1 != &static_value && !(_mask & (_mask - 1)));
    uint32_t expected = *_v.v1;
#if !CLICK_USERLEVEL || HAVE_MULTITHREAD
    while (_mask) {
#if ! CLICK_ATOMIC_COMPARE_SWAP
        // TODO: is it equivalent to compare_swap branch?
        uint32_t desired = (active ? expected | _mask : expected & ~_mask);
        if(_v.v1->compare_and_swap(expected, desired))
            break;
        expected = *(_v.v1);
 
#else
        uint32_t desired = (active ? expected | _mask : expected & ~_mask);
        uint32_t actual = _v.v1->compare_swap(expected, desired);
        if (expected == actual)
            break;
        expected = actual;
#endif
    }
#else
    *_v.v1 = (active ? expected | _mask : expected & ~_mask);
#endif
    return expected & _mask;
}
 
inline NotifierSignal& NotifierSignal::operator=(const NotifierSignal& x) {
    if (likely(this != &x)) {
        if (unlikely(_mask == 0))
            delete[] _v.vm;
        _mask = x._mask;
        if (likely(_mask))
            _v.v1 = x._v.v1;
        else
            hard_assign_vm(x);
    }
    return *this;
}
 
inline void NotifierSignal::swap(NotifierSignal& x) {
    click_swap(_v, x._v);
    click_swap(_mask, x._mask);
}
 
inline bool operator==(const NotifierSignal& a, const NotifierSignal& b) {
    if (a._mask == b._mask) {
        if (likely(a._mask))
            return a._v.v1 == b._v.v1;
        else
            return NotifierSignal::hard_equals(a._v.vm, b._v.vm);
    } else
        return false;
}
 
inline bool operator!=(const NotifierSignal& a, const NotifierSignal& b) {
    return !(a == b);
}
 
inline NotifierSignal operator+(NotifierSignal a, const NotifierSignal& b) {
    return a += b;
}
 
inline Notifier::Notifier(SearchOp op)
    : _signal(NotifierSignal::uninitialized_signal()), _search_op(op) {
}
 
inline Notifier::Notifier(const NotifierSignal &signal, SearchOp op)
    : _signal(signal), _search_op(op) {
}
 
inline const NotifierSignal& Notifier::signal() const {
    return _signal;
}
 
inline Notifier::SearchOp Notifier::search_op() const {
    return _search_op;
}
 
inline bool Notifier::active() const {
    return _signal.active();
}
 
inline bool Notifier::safe_active() const {
    return _signal.safe_active();
}
 
inline bool Notifier::set_active(bool active) {
    return _signal.set_active(active);
}
 
inline void Notifier::wake() {
    set_active(true);
}
 
inline void Notifier::sleep() {
    set_active(false);
}
 
inline int Notifier::add_listener(Task* task) {
    return add_activate_callback(0, task);
}
 
inline void Notifier::remove_listener(Task* task) {
    remove_activate_callback(0, task);
}
 
inline int Notifier::add_dependent_signal(NotifierSignal* signal) {
    return add_activate_callback(dependent_signal_callback, signal);
}
 
inline void Notifier::remove_dependent_signal(NotifierSignal* signal) {
    remove_activate_callback(dependent_signal_callback, signal);
}
 
inline NotifierSignal Notifier::upstream_empty_signal(Element* e, int port) {
    return upstream_signal(e, port, (callback_type) 0, 0, Notifier::EMPTY_NOTIFIER);
}
 
inline NotifierSignal Notifier::upstream_empty_signal(Element* e, int port,
                                                      Task* task) {
    return upstream_signal(e, port, (callback_type) 0, task, Notifier::EMPTY_NOTIFIER);
}
 
inline NotifierSignal Notifier::upstream_signal(Element* e, int port,
                                                      Task* task, const char * signal) {
    return upstream_signal(e, port, (callback_type) 0, task, signal);
}
 
inline NotifierSignal Notifier::upstream_empty_signal(Element* e, int port,
                                                      Notifier* dependent_notifier) {
    return upstream_signal(e, port, dependent_signal_callback, &dependent_notifier->_signal, Notifier::EMPTY_NOTIFIER);
}
 
 
inline NotifierSignal Notifier::upstream_empty_signal(Element* e, int port, callback_type f, void *user_data)
{
        return upstream_signal(e,port,f,user_data,Notifier::EMPTY_NOTIFIER);
}
 
inline NotifierSignal Notifier::downstream_full_signal(Element* e, int port) {
    return downstream_full_signal(e, port, (callback_type) 0, 0);
}
 
inline NotifierSignal Notifier::downstream_full_signal(Element* e, int port,
                                                       Task* task) {
    return downstream_full_signal(e, port, (callback_type) 0, task);
}
 
inline NotifierSignal Notifier::downstream_full_signal(Element* e, int port,
                                                       Notifier* dependent_notifier) {
    return downstream_full_signal(e, port, dependent_signal_callback, &dependent_notifier->_signal);
}
 
inline NotifierSignal Notifier::upstream_empty_signal(Element* e, int port, int x) {
    (void) x;
    assert(x == 0);
    return upstream_empty_signal(e, port);
}
 
inline NotifierSignal Notifier::upstream_empty_signal(Element* e, int port, int x,
                                                      Notifier* notifier) {
    (void) x;
    assert(x == 0);
    return upstream_empty_signal(e, port, notifier);
}
 
inline NotifierSignal Notifier::downstream_full_signal(Element* e, int port, int x) {
    (void) x;
    assert(x == 0);
    return downstream_full_signal(e, port);
}
 
inline NotifierSignal Notifier::downstream_full_signal(Element* e, int port, int x,
                                                       Notifier* notifier) {
    (void) x;
    assert(x == 0);
    return downstream_full_signal(e, port, notifier);
}
inline void ActiveNotifier::set_active(bool active, bool schedule) {
    bool was_active = Notifier::set_active(active);
    if (active && schedule && !was_active) {
        // 2007.Sep.6: Perhaps there was a race condition here.  Make sure
        // that we set the notifier to active BEFORE rescheduling downstream
        // tasks.  This is because, in a multithreaded environment, a task we
        // reschedule might run BEFORE we set the notifier; after which it
        // would go to sleep forever.
        if (_listener1)
            _listener1->reschedule();
        else if (task_or_signal_t *tos = _listeners) {
            for (; tos->p > 1; tos++)
                tos->t->reschedule();
            if (tos->p == 1)
                for (tos++; tos->p; tos += 2)
                    tos->f(tos[1].v, this);
        }
    }
}
 
inline void ActiveNotifier::wake() {
    set_active(true, true);
}
 
inline void ActiveNotifier::sleep() {
    set_active(false, true);
}
 
inline void click_swap(NotifierSignal& x, NotifierSignal& y) {
    x.swap(y);
}
 
CLICK_ENDDECLS
#endif