Eigen::EventCount Class Reference

Classes
class	Waiter

Public Member Functions
void	CancelWait ()
void	CommitWait (Waiter *w)
	EventCount (MaxSizeVector< Waiter > &waiters)
void	Notify (bool notifyAll)
void	Prewait ()
	~EventCount ()

Private Member Functions
	EventCount (const EventCount &)=delete
void	operator= (const EventCount &)=delete
void	Park (Waiter *w)
void	Unpark (Waiter *w)

Static Private Member Functions
static void	CheckState (uint64_t state, bool waiter=false)

Private Attributes
std::atomic< uint64_t >	state_
MaxSizeVector< Waiter > &	waiters_

Static Private Attributes
static const uint64_t	kEpochBits
static const uint64_t	kEpochInc
static const uint64_t	kEpochMask
static const uint64_t	kEpochShift
static const uint64_t	kSignalInc
static const uint64_t	kSignalMask
static const uint64_t	kSignalShift
static const uint64_t	kStackMask
static const uint64_t	kWaiterBits
static const uint64_t	kWaiterInc
static const uint64_t	kWaiterMask
static const uint64_t	kWaiterShift

Detailed Description

Definition at line 51 of file EventCount.h.

Constructor & Destructor Documentation

EventCount() [1/2]

Eigen::EventCount::EventCount ( MaxSizeVector< Waiter > &  waiters )

inline

Definition at line 55 of file EventCount.h.

      : state_(kStackMask), waiters_(waiters) {
    eigen_plain_assert(waiters.size() < (1 << kWaiterBits) - 1);
  }

~EventCount()

Eigen::EventCount::~EventCount ( )

inline

Definition at line 60 of file EventCount.h.

                {
    // Ensure there are no waiters.
    eigen_plain_assert(state_.load() == kStackMask);
  }

EventCount() [2/2]

Eigen::EventCount::EventCount ( const EventCount &  )

privatedelete

Member Function Documentation

CancelWait()

void Eigen::EventCount::CancelWait ( )

inline

Definition at line 111 of file EventCount.h.

                    {
    uint64_t state = state_.load(std::memory_order_relaxed);
    for (;;) {
      CheckState(state, true);
      uint64_t newstate = state - kWaiterInc;
      // We don't know if the thread was also notified or not,
      // so we should not consume a signal unconditionally.
      // Only if number of waiters is equal to number of signals,
      // we know that the thread was notified and we must take away the signal.
      if (((state & kWaiterMask) >> kWaiterShift) ==
          ((state & kSignalMask) >> kSignalShift))
        newstate -= kSignalInc;
      CheckState(newstate);
      if (state_.compare_exchange_weak(state, newstate,
                                       std::memory_order_acq_rel))
        return;
    }
  }

CheckState()

static void Eigen::EventCount::CheckState ( uint64_t  state, bool  waiter = false  )

inlinestaticprivate

Definition at line 211 of file EventCount.h.

                                                              {
    static_assert(kEpochBits >= 20, "not enough bits to prevent ABA problem");
    const uint64_t waiters = (state & kWaiterMask) >> kWaiterShift;
    const uint64_t signals = (state & kSignalMask) >> kSignalShift;
    eigen_plain_assert(waiters >= signals);
    eigen_plain_assert(waiters < (1 << kWaiterBits) - 1);
    eigen_plain_assert(!waiter || waiters > 0);
    (void)waiters;
    (void)signals;
  }

CommitWait()

void Eigen::EventCount::CommitWait ( Waiter *  w )

inline

Definition at line 81 of file EventCount.h.

                             {
    eigen_plain_assert((w->epoch & ~kEpochMask) == 0);
    w->state = Waiter::kNotSignaled;
    const uint64_t me = (w - &waiters_[0]) | w->epoch;
    uint64_t state = state_.load(std::memory_order_seq_cst);
    for (;;) {
      CheckState(state, true);
      uint64_t newstate;
      if ((state & kSignalMask) != 0) {
        // Consume the signal and return immediately.
        newstate = state - kWaiterInc - kSignalInc;
      } else {
        // Remove this thread from pre-wait counter and add to the waiter stack.
        newstate = ((state & kWaiterMask) - kWaiterInc) | me;
        w->next.store(state & (kStackMask | kEpochMask),
                      std::memory_order_relaxed);
      }
      CheckState(newstate);
      if (state_.compare_exchange_weak(state, newstate,
                                       std::memory_order_acq_rel)) {
        if ((state & kSignalMask) == 0) {
          w->epoch += kEpochInc;
          Park(w);
        }
        return;
      }
    }
  }

Notify()

void Eigen::EventCount::Notify ( bool  notifyAll )

inline

Definition at line 132 of file EventCount.h.

                              {
    std::atomic_thread_fence(std::memory_order_seq_cst);
    uint64_t state = state_.load(std::memory_order_acquire);
    for (;;) {
      CheckState(state);
      const uint64_t waiters = (state & kWaiterMask) >> kWaiterShift;
      const uint64_t signals = (state & kSignalMask) >> kSignalShift;
      // Easy case: no waiters.
      if ((state & kStackMask) == kStackMask && waiters == signals) return;
      uint64_t newstate;
      if (notifyAll) {
        // Empty wait stack and set signal to number of pre-wait threads.
        newstate =
            (state & kWaiterMask) | (waiters << kSignalShift) | kStackMask;
      } else if (signals < waiters) {
        // There is a thread in pre-wait state, unblock it.
        newstate = state + kSignalInc;
      } else {
        // Pop a waiter from list and unpark it.
        Waiter* w = &waiters_[state & kStackMask];
        uint64_t next = w->next.load(std::memory_order_relaxed);
        newstate = (state & (kWaiterMask | kSignalMask)) | next;
      }
      CheckState(newstate);
      if (state_.compare_exchange_weak(state, newstate,
                                       std::memory_order_acq_rel)) {
        if (!notifyAll && (signals < waiters))
          return;  // unblocked pre-wait thread
        if ((state & kStackMask) == kStackMask) return;
        Waiter* w = &waiters_[state & kStackMask];
        if (!notifyAll) w->next.store(kStackMask, std::memory_order_relaxed);
        Unpark(w);
        return;
      }
    }
  }

operator=()

void Eigen::EventCount::operator= ( const EventCount &  )

privatedelete

Park()

void Eigen::EventCount::Park ( Waiter *  w )

inlineprivate

Definition at line 222 of file EventCount.h.

                       {
    EIGEN_MUTEX_LOCK lock(w->mu);
    while (w->state != Waiter::kSignaled) {
      w->state = Waiter::kWaiting;
      w->cv.wait(lock);
    }
  }

Prewait()

void Eigen::EventCount::Prewait ( )

inline

Definition at line 68 of file EventCount.h.

                 {
    uint64_t state = state_.load(std::memory_order_relaxed);
    for (;;) {
      CheckState(state);
      uint64_t newstate = state + kWaiterInc;
      CheckState(newstate);
      if (state_.compare_exchange_weak(state, newstate,
                                       std::memory_order_seq_cst))
        return;
    }
  }

Unpark()

void Eigen::EventCount::Unpark ( Waiter *  w )

inlineprivate

Definition at line 230 of file EventCount.h.

                         {
    for (Waiter* next; w; w = next) {
      uint64_t wnext = w->next.load(std::memory_order_relaxed) & kStackMask;
      next = wnext == kStackMask ? nullptr : &waiters_[internal::convert_index<size_t>(wnext)];
      unsigned state;
      {
        EIGEN_MUTEX_LOCK lock(w->mu);
        state = w->state;
        w->state = Waiter::kSignaled;
      }
      // Avoid notifying if it wasn't waiting.
      if (state == Waiter::kWaiting) w->cv.notify_one();
    }
  }

Member Data Documentation

kEpochBits

const uint64_t Eigen::EventCount::kEpochBits

staticprivate

Definition at line 205 of file EventCount.h.

kEpochInc

const uint64_t Eigen::EventCount::kEpochInc

staticprivate

Definition at line 207 of file EventCount.h.

kEpochMask

const uint64_t Eigen::EventCount::kEpochMask

staticprivate

Definition at line 206 of file EventCount.h.

kEpochShift

const uint64_t Eigen::EventCount::kEpochShift

staticprivate

Definition at line 204 of file EventCount.h.

kSignalInc

const uint64_t Eigen::EventCount::kSignalInc

staticprivate

Definition at line 203 of file EventCount.h.

kSignalMask

const uint64_t Eigen::EventCount::kSignalMask

staticprivate

Definition at line 201 of file EventCount.h.

kSignalShift

const uint64_t Eigen::EventCount::kSignalShift

staticprivate

Definition at line 200 of file EventCount.h.

kStackMask

const uint64_t Eigen::EventCount::kStackMask

staticprivate

Definition at line 195 of file EventCount.h.

kWaiterBits

const uint64_t Eigen::EventCount::kWaiterBits

staticprivate

Definition at line 194 of file EventCount.h.

kWaiterInc

const uint64_t Eigen::EventCount::kWaiterInc

staticprivate

Definition at line 199 of file EventCount.h.

kWaiterMask

const uint64_t Eigen::EventCount::kWaiterMask

staticprivate

Definition at line 197 of file EventCount.h.

kWaiterShift

const uint64_t Eigen::EventCount::kWaiterShift

staticprivate

Definition at line 196 of file EventCount.h.

state_

std::atomic<uint64_t> Eigen::EventCount::state_

private

Definition at line 208 of file EventCount.h.

waiters_

MaxSizeVector<Waiter>& Eigen::EventCount::waiters_

private

Definition at line 209 of file EventCount.h.

---

The documentation for this class was generated from the following file:

• EventCount.h