folly::detail::LifoSemHead Class Reference

#include <LifoSem.h>

Public Member Functions
uint32_t	idx () const
uint32_t	value () const
constexpr bool	isNodeIdx () const
constexpr bool	isShutdown () const
constexpr bool	isLocked () const
constexpr uint32_t	seq () const
LifoSemHead	withPop (uint32_t idxNext) const
LifoSemHead	withPush (uint32_t _idx) const
	Returns the LifoSemHead that results from pushing a new waiter node. More...
LifoSemHead	withValueIncr (uint32_t delta) const
LifoSemHead	withValueDecr (uint32_t delta) const
	Returns the LifoSemHead that results from decrementing the value. More...
LifoSemHead	withShutdown () const
LifoSemHead	withLock () const
LifoSemHead	withoutLock (uint32_t idxNext) const
constexpr bool	operator== (const LifoSemHead &rhs) const
constexpr bool	operator!= (const LifoSemHead &rhs) const

Static Public Member Functions
static constexpr LifoSemHead	fresh (uint32_t value)

Public Attributes
uint64_t	bits

Private Types
enum	{ IsNodeIdxShift = 32, IsShutdownShift = 33, IsLockedShift = 34, SeqShift = 35 }
enum	: uint64_t {   IsNodeIdxMask = uint64_t(1) << IsNodeIdxShift, IsShutdownMask = uint64_t(1) << IsShutdownShift, IsLockedMask = uint64_t(1) << IsLockedShift, SeqIncr = uint64_t(1) << SeqShift,   SeqMask = ~(SeqIncr - 1) }

Detailed Description

LifoSemHead is a 64-bit struct that holds a 32-bit value, some state bits, and a sequence number used to avoid ABA problems in the lock-free management of the LifoSem's wait lists. The value can either hold an integral semaphore value (if there are no waiters) or a node index (see IndexedMemPool) for the head of a list of wait nodes

Definition at line 209 of file LifoSem.h.

Member Enumeration Documentation

anonymous enum

private

Enumerator
IsNodeIdxShift
IsShutdownShift
IsLockedShift
SeqShift

Definition at line 222 of file LifoSem.h.

       {
    IsNodeIdxShift = 32,
    IsShutdownShift = 33,
    IsLockedShift = 34,
    SeqShift = 35,
  };

anonymous enum : uint64_t

private

Enumerator
IsNodeIdxMask
IsShutdownMask
IsLockedMask
SeqIncr
SeqMask

Definition at line 228 of file LifoSem.h.

       : uint64_t {
    IsNodeIdxMask = uint64_t(1) << IsNodeIdxShift,
    IsShutdownMask = uint64_t(1) << IsShutdownShift,
    IsLockedMask = uint64_t(1) << IsLockedShift,
    SeqIncr = uint64_t(1) << SeqShift,
    SeqMask = ~(SeqIncr - 1),
  };

Member Function Documentation

static constexpr LifoSemHead folly::detail::LifoSemHead::fresh ( uint32_t  value )

inlinestatic

This should only be used for initial construction, not for setting the value, because it clears the sequence number

Definition at line 267 of file LifoSem.h.

                                                            {
    return LifoSemHead{value};
  }

uint32_t folly::detail::LifoSemHead::idx ( ) const

inline

Definition at line 241 of file LifoSem.h.

References uint32_t.

                              {
    assert(isNodeIdx());
    assert(uint32_t(bits) != 0);
    return uint32_t(bits);
  }

constexpr bool folly::detail::LifoSemHead::isLocked ( ) const

inline

Definition at line 256 of file LifoSem.h.

                                         {
    return (bits & IsLockedMask) != 0;
  }

constexpr bool folly::detail::LifoSemHead::isNodeIdx ( ) const

inline

Definition at line 250 of file LifoSem.h.

                                          {
    return (bits & IsNodeIdxMask) != 0;
  }

constexpr bool folly::detail::LifoSemHead::isShutdown ( ) const

inline

Definition at line 253 of file LifoSem.h.

                                           {
    return (bits & IsShutdownMask) != 0;
  }

constexpr bool folly::detail::LifoSemHead::operator!= ( const LifoSemHead &  rhs ) const

inline

Definition at line 339 of file LifoSem.h.

References Atom, and folly::detail::rhs.

                                                                 {
    return !(*this == rhs);
  }

constexpr bool folly::detail::LifoSemHead::operator== ( const LifoSemHead &  rhs ) const

inline

Definition at line 336 of file LifoSem.h.

References bits.

                                                                 {
    return bits == rhs.bits;
  }

constexpr uint32_t folly::detail::LifoSemHead::seq ( ) const

inline

Definition at line 259 of file LifoSem.h.

References uint32_t.

                                        {
    return uint32_t(bits >> SeqShift);
  }

uint32_t folly::detail::LifoSemHead::value ( ) const

inline

Definition at line 246 of file LifoSem.h.

References uint32_t.

                                {
    assert(!isNodeIdx());
    return uint32_t(bits);
  }

LifoSemHead folly::detail::LifoSemHead::withLock ( ) const

inline

Definition at line 323 of file LifoSem.h.

                                      {
    assert(!isLocked());
    return LifoSemHead{bits | IsLockedMask};
  }

LifoSemHead folly::detail::LifoSemHead::withoutLock ( uint32_t  idxNext ) const

inline

Definition at line 330 of file LifoSem.h.

References withPop().

                                                         {
    assert(isLocked());
    // We need to treat this as a pop, as we may change the list head.
    return LifoSemHead{bits & ~IsLockedMask}.withPop(idxNext);
  }

LifoSemHead folly::detail::LifoSemHead::withPop ( uint32_t  idxNext ) const

inline

Returns the LifoSemHead that results from popping a waiter node, given the current waiter node's next ptr

Definition at line 273 of file LifoSem.h.

Referenced by withoutLock().

                                                     {
    assert(!isLocked());
    assert(isNodeIdx());
    if (idxNext == 0) {
      // no isNodeIdx bit or data bits.  Wraparound of seq bits is okay
      return LifoSemHead{(bits & (SeqMask | IsShutdownMask)) + SeqIncr};
    } else {
      // preserve sequence bits (incremented with wraparound okay) and
      // isNodeIdx bit, replace all data bits
      return LifoSemHead{(bits & (SeqMask | IsShutdownMask | IsNodeIdxMask)) +
                         SeqIncr + idxNext};
    }
  }

LifoSemHead folly::detail::LifoSemHead::withPush ( uint32_t  _idx ) const

inline

Returns the LifoSemHead that results from pushing a new waiter node.

Definition at line 288 of file LifoSem.h.

References folly::value().

                                                   {
    assert(!isLocked());
    assert(isNodeIdx() || value() == 0);
    assert(!isShutdown());
    assert(_idx != 0);
    return LifoSemHead{(bits & SeqMask) | IsNodeIdxMask | _idx};
  }

LifoSemHead folly::detail::LifoSemHead::withShutdown ( ) const

inline

Returns the LifoSemHead with the same state as the current node, but with the shutdown bit set

Definition at line 318 of file LifoSem.h.

                                          {
    return LifoSemHead{bits | IsShutdownMask};
  }

LifoSemHead folly::detail::LifoSemHead::withValueDecr ( uint32_t  delta ) const

inline

Returns the LifoSemHead that results from decrementing the value.

Definition at line 310 of file LifoSem.h.

References folly::value().

                                                         {
    assert(!isLocked());
    assert(delta > 0 && delta <= value());
    return LifoSemHead{bits + SeqIncr - delta};
  }

LifoSemHead folly::detail::LifoSemHead::withValueIncr ( uint32_t  delta ) const

inline

Returns the LifoSemHead with value increased by delta, with saturation if the maximum value is reached

Definition at line 298 of file LifoSem.h.

References UNLIKELY.

                                                         {
    assert(!isLocked());
    assert(!isNodeIdx());
    auto rv = LifoSemHead{bits + SeqIncr + delta};
    if (UNLIKELY(rv.isNodeIdx())) {
      // value has overflowed into the isNodeIdx bit
      rv = LifoSemHead{(rv.bits & ~IsNodeIdxMask) | (IsNodeIdxMask - 1)};
    }
    return rv;
  }

Member Data Documentation

uint64_t folly::detail::LifoSemHead::bits

Definition at line 237 of file LifoSem.h.

Referenced by operator==().

---

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

• proxygen/folly/folly/synchronization/LifoSem.h