New bitfield syntax.

Bitfield members now accessed via a union instead of accessor functions.
Direct assignment/++ instead of get(), set(), add().
Array members support operator[].

Author: preshing

common/bitfield.h

@@ -9,152 +9,128 @@
 #include <cassert>
 
 
-//---------------------------------------------------------
-// BitField<>: Used internally by BEGIN_BITFIELD_TYPE macro.
-// T is expected to be an unsigned integral type.
-//---------------------------------------------------------
-template <class T>
-struct BitField
-{
-    typedef T IntType;
-    T value;
-
-    BitField(T v = 0) : value(v) {}
-    BitField& baseCast() { return *this; }
-    const BitField& baseCast() const { return *this; }
-};
-
-
 //---------------------------------------------------------
 // BitFieldMember<>: Used internally by ADD_BITFIELD_MEMBER macro.
 //---------------------------------------------------------
 template <class T, int Offset, int Bits>
-struct BitFieldMember : BitField<T>
+class BitFieldMember
 {
+private:
     static_assert(Offset + Bits <= (int) sizeof(T) * 8, "Member exceeds bitfield boundaries");
     static_assert(Bits < (int) sizeof(T) * 8, "Can't fill entire bitfield with one member");
 
-    // Compile-time constants.
-    // Not easy to access since the template instance is wrapped in a macro.
-    // You can get at them using eg. BitFieldType().member().maximum() instead.
     static const T Maximum = (T(1) << Bits) - 1;
     static const T Mask = Maximum << Offset;
 
-    // Can't instantiate this class directly.
-    // Must instead cast from BitField<T>.
-    // That's what ADD_BITFIELD_MEMBER does.
-    BitFieldMember() = delete;
+    T value;
 
+public:
     T maximum() const { return Maximum; }
     T one() const { return T(1) << Offset; }
 
-    T get() const
+    operator T() const
     {
-        return (this->value >> Offset) & Maximum;
+        return (value >> Offset) & Maximum;
     }
 
-    void set(T v)
+    BitFieldMember& operator=(T v)
     {
-        assert(v <= Maximum);   // v must fit inside the bitfield member
-        this->value = (this->value & ~Mask) | (v << Offset);
+        assert(v <= Maximum);               // v must fit inside the bitfield member
+        value = (value & ~Mask) | (v << Offset);
+        return *this;
     }
 
-    void setWrapped(T v)
+    BitFieldMember& operator+=(T v)
     {
-        this->value = (this->value & ~Mask) | ((v & Maximum) << Offset);
+        assert(T(*this) + v <= Maximum);    // result must fit inside the bitfield member
+        value += v << Offset;
+        return *this;
     }
 
-    void add(T v)
+    BitFieldMember& operator-=(T v)
     {
-        assert(get() + v <= Maximum);   // result must fit inside the bitfield member
-        this->value += v << Offset;
+        assert(T(*this) >= v);              // result must not underflow
+        value -= v << Offset;
+        return *this;
     }
 
-    void addWrapped(T v)
-    {
-        this->value = (this->value & ~Mask) | ((this->value + (v << Offset)) & Mask);
-    }
-
-    void sub(T v)
-    {
-        assert(get() >= v);     // result must not underflow
-        this->value -= v << Offset;
-    }
-
-    void subWrapped(T v)
-    {
-        this->value = (this->value & ~Mask) | ((this->value - (v << Offset)) & Mask);
-    }
+    BitFieldMember& operator++() { return *this += 1; }
+    BitFieldMember& operator++(int) { return *this += 1; }    // postfix form
+    BitFieldMember& operator--() { return *this -= 1; }
+    BitFieldMember& operator--(int) { return *this -= 1; }    // postfix form
 };
 
 
 //---------------------------------------------------------
 // BitFieldArray<>: Used internally by ADD_BITFIELD_ARRAY macro.
 //---------------------------------------------------------
 template <class T, int BaseOffset, int BitsPerItem, int NumItems>
-struct BitFieldArray : BitField<T>
+class BitFieldArray
 {
+private:
     static_assert(BaseOffset + BitsPerItem * NumItems <= (int) sizeof(T) * 8, "Array exceeds bitfield boundaries");
     static_assert(BitsPerItem < (int) sizeof(T) * 8, "Can't fill entire bitfield with one array element");
 
-    // Compile-time constants.
-    // Not easy to access since the template instance is wrapped in a macro.
-    // You can get at them using eg. BitFieldType().member().maximum() instead.
     static const T Maximum = (T(1) << BitsPerItem) - 1;
 
-    // Can't instantiate this class directly.
-    // Must instead cast from BitField<T>.
-    // That's what ADD_BITFIELD_ARRAY does.
-    BitFieldArray() = delete;
-
-    T maximum() const { return Maximum; }
-    int offset(int i) const
-    {
-        assert(i >= 0 && i < NumItems);     // array index must be in range
-        return BaseOffset + BitsPerItem * i;
-    }
-    T one(int i) const { return T(1) << offset(i); }
-    T mask(int i) const { return Maximum << offset(i); }
-    int numItems() const { return NumItems; }
-
-    T get(int i) const
-    {
-        return (this->value >> offset(i)) & Maximum;
-    }
-
-    void set(int i, T v)
-    {
-        assert(v <= Maximum);   // v must fit inside the bitfield member
-        this->value = (this->value & ~mask(i)) | (v << offset(i));
-    }
-
-    void setWrapped(int i, T v)
-    {
-        this->value = (this->value & ~mask(i)) | ((v & Maximum) << offset(i));
-    }
+    T value;
 
-    void add(int i, T v)
+    class Element
     {
-        assert(get(i) + v <= Maximum);   // result must fit inside the bitfield member
-        this->value += v << offset(i);
-    }
+    private:
+        T& value;
+        int offset;
+
+    public:
+        Element(T& value, int offset) : value(value), offset(offset) {}
+        T mask() const { return Maximum << offset; }
+
+        operator T() const
+        {
+            return (value >> offset) & Maximum;
+        }
+
+        Element& operator=(T v)
+        {
+            assert(v <= Maximum);               // v must fit inside the bitfield member
+            value = (value & ~mask()) | (v << offset);
+            return *this;
+        }
+
+        Element& operator+=(T v)
+        {
+            assert(T(*this) + v <= Maximum);    // result must fit inside the bitfield member
+            value += v << offset;
+            return *this;
+        }
+
+        Element& operator-=(T v)
+        {
+            assert(T(*this) >= v);               // result must not underflow
+            value -= v << offset;
+            return *this;
+        }
+
+        Element& operator++() { return *this += 1; }
+        Element& operator++(int) { return *this += 1; }    // postfix form
+        Element& operator--() { return *this -= 1; }
+        Element& operator--(int) { return *this -= 1; }    // postfix form
+    };
 
-    void addWrapped(int i, T v)
-    {
-        T m = mask(i);
-        this->value = (this->value & ~m) | ((this->value + (v << offset(i))) & m);
-    }
+public:
+    T maximum() const { return Maximum; }
+    int numItems() const { return NumItems; }
 
-    void sub(int i, T v)
+    Element operator[](int i)
     {
-        assert(get(i) >= v);    // result must not underflow
-        this->value -= v << offset(i);
+        assert(i >= 0 && i < NumItems);     // array index must be in range
+        return Element(value, BaseOffset + BitsPerItem * i);
     }
 
-    void subWrapped(int i, T v)
+    const Element operator[](int i) const
     {
-        T m = mask(i);
-        this->value = (this->value & ~m) | ((this->value - (v << offset(i))) & m);
+        assert(i >= 0 && i < NumItems);     // array index must be in range
+        return Element(value, BaseOffset + BitsPerItem * i);
     }
 };
 
@@ -164,17 +140,22 @@ struct BitFieldArray : BitField<T>
 // For usage examples, see RWLock and LockReducedDiningPhilosophers.
 //---------------------------------------------------------
 #define BEGIN_BITFIELD_TYPE(typeName, T) \
-    struct typeName : BitField<T> \
+    union typeName \
     { \
-        typeName(T v = 0) : BitField(v) {}
+    private: \
+        typedef T _IntType; \
+        T value; \
+    public: \
+        typeName(T v = 0) : value(v) {} \
+        typeName& operator=(T v) { value = v; return *this; } \
+        operator T&() { return value; } \
+        operator T() const { return value; }
 
 #define ADD_BITFIELD_MEMBER(memberName, offset, bits) \
-        BitFieldMember<IntType, offset, bits>& memberName() { return static_cast<BitFieldMember<IntType, offset, bits>&>(baseCast()); } \
-        const BitFieldMember<IntType, offset, bits>& memberName() const { return static_cast<const BitFieldMember<IntType, offset, bits>&>(baseCast()); }
+        BitFieldMember<_IntType, offset, bits> memberName;
 
-#define ADD_BITFIELD_ARRAY(memberName, offset, bitsPerItem, numItems) \
-        BitFieldArray<IntType, offset, bitsPerItem, numItems>& memberName() { return static_cast<BitFieldArray<IntType, offset, bitsPerItem, numItems>&>(baseCast()); } \
-        const BitFieldArray<IntType, offset, bitsPerItem, numItems>& memberName() const { return static_cast<const BitFieldArray<IntType, offset, bitsPerItem, numItems>&>(baseCast()); }
+#define ADD_BITFIELD_ARRAY(memberName, offset, bits, numItems) \
+        BitFieldArray<_IntType, offset, bits, numItems> memberName;
 
 #define END_BITFIELD_TYPE() \
     };

common/diningphilosophers.h

@@ -162,7 +162,7 @@ class LockReducedDiningPhilosophers
     int m_numPhilos;
 
     // Lock-free "box office".
-    // AllStatus::philos() keeps track of the status of each philosopher (thread).
+    // AllStatus::philos keeps track of the status of each philosopher (thread).
     // 0: Philosopher is thinking
     // 1: Philosopher is eating
     // 2+: Philosopher is waiting and must not eat before his/her direct neighbors if they have a lower status.
@@ -193,19 +193,19 @@ class LockReducedDiningPhilosophers
     bool tryAdjustStatus(AllStatus& allStatus, int philoIndex, int target, int step) const
     {
         // Should not already have the target status.
-        assert(allStatus.philos().get(philoIndex) != target);
-        if (allStatus.philos().get(philoIndex) == target + 1)
+        assert(allStatus.philos[philoIndex] != target);
+        if (allStatus.philos[philoIndex] == target + 1)
         {
             // Decrementing this status will bring it to target.
             // Make sure the next neighbor doesn't prevent it.
             int n = neighbor(philoIndex, step);
-            assert(allStatus.philos().get(n) != target + 1);    // No two neighbors should have equal status > 0.
-            if (allStatus.philos().get(n) != target)
+            assert(allStatus.philos[n] != target + 1);    // No two neighbors should have equal status > 0.
+            if (allStatus.philos[n] != target)
             {
                 // Decrement it.
-                allStatus.philos().set(philoIndex, target);
+                allStatus.philos[philoIndex] = target;
                 // If neighbor's status is exactly 1 greater, continue visiting.
-                if (allStatus.philos().get(n) > IntType(target))
+                if (allStatus.philos[n] > IntType(target))
                     tryAdjustStatus(allStatus, n, target + 1, step);
                 return true;
             }
@@ -218,8 +218,8 @@ class LockReducedDiningPhilosophers
     : m_numPhilos(numPhilos)
     , m_allStatus(0)
     {
-        assert(IntType(numPhilos) <= AllStatus().philos().maximum());
-        assert(numPhilos < AllStatus().philos().numItems());
+        assert(IntType(numPhilos) <= AllStatus().philos.maximum());
+        assert(numPhilos < AllStatus().philos.numItems());
         m_sema = std::unique_ptr<DefaultSemaphoreType[]>(new DefaultSemaphoreType[numPhilos]);
     }
 
@@ -230,16 +230,16 @@ class LockReducedDiningPhilosophers
         AllStatus oldStatus = m_allStatus.load(std::memory_order_relaxed);
         for (;;)    // Begin CAS loop
         {
-            assert(oldStatus.philos().get(philoIndex) == 0);    // Must have been thinking
+            assert(oldStatus.philos[philoIndex] == 0);    // Must have been thinking
             // Establish order relative to direct neighbors.
-            maxNeighborStatus = std::max(oldStatus.philos().get(left(philoIndex)), oldStatus.philos().get(right(philoIndex)));
+            maxNeighborStatus = std::max(oldStatus.philos[left(philoIndex)], oldStatus.philos[right(philoIndex)]);
             AllStatus newStatus(oldStatus);
-            newStatus.philos().set(philoIndex, maxNeighborStatus + 1);
+            newStatus.philos[philoIndex] = maxNeighborStatus + 1;
             // Sanity check.
             for (int i = 0; i < m_numPhilos; i++)
-                assert(newStatus.philos().get(i) <= IntType(m_numPhilos));
+                assert(newStatus.philos[i] <= IntType(m_numPhilos));
             // CAS until successful. On failure, oldStatus will be updated with the latest value.
-            if (m_allStatus.compare_exchange_strong(oldStatus.value, newStatus.value, std::memory_order_relaxed))
+            if (m_allStatus.compare_exchange_strong(oldStatus, newStatus, std::memory_order_relaxed))
                 break;
         }
 
@@ -258,11 +258,11 @@ class LockReducedDiningPhilosophers
         AllStatus oldStatus = m_allStatus.load(std::memory_order_relaxed);
         for (;;)    // Begin CAS loop
         {
-            assert(oldStatus.philos().get(philoIndex) == 1);    // Must have been eating
+            assert(oldStatus.philos[philoIndex] == 1);    // Must have been eating
             AllStatus newStatus(oldStatus);
-            newStatus.philos().set(philoIndex, 0);
+            newStatus.philos[philoIndex] = 0;
             // Choose which neighbor to visit first based on priority
-            if (newStatus.philos().get(firstNeighbor) > newStatus.philos().get(secondNeighbor))
+            if (newStatus.philos[firstNeighbor] > newStatus.philos[secondNeighbor])
             {
                 std::swap(firstNeighbor, secondNeighbor);
                 stepFirst = m_numPhilos - stepFirst;
@@ -272,9 +272,9 @@ class LockReducedDiningPhilosophers
             secondWillEat = tryAdjustStatus(newStatus, secondNeighbor, 1, m_numPhilos - stepFirst);
             // Sanity check.
             for (int i = 0; i < m_numPhilos; i++)
-                assert(newStatus.philos().get(i) <= IntType(m_numPhilos));
+                assert(newStatus.philos[i] <= IntType(m_numPhilos));
             // CAS until successful. On failure, oldStatus will be updated with the latest value.
-            if (m_allStatus.compare_exchange_strong(oldStatus.value, newStatus.value, std::memory_order_relaxed))
+            if (m_allStatus.compare_exchange_strong(oldStatus, newStatus, std::memory_order_relaxed))
                 break;
         }