Merge pull request #182 from elbeno/fix-atomic-bitset-reset

🐛 Fix `atomic_bitset::reset` for order

Author: lukevalenty

include/stdx/atomic_bitset.hpp

@@ -159,28 +159,35 @@ class atomic_bitset {
         return *this;
     }
 
-    template <typename T> auto reset(T idx) -> bitset_t {
+    template <typename T>
+    auto reset(T idx, std::memory_order order = std::memory_order_seq_cst)
+        -> bitset_t {
         auto const pos = static_cast<std::size_t>(to_underlying(idx));
-        return bitset_t{
-            atomic::fetch_and(storage, static_cast<elem_t>(~(bit << pos)))};
-    }
-
-    auto reset(std::memory_order order = std::memory_order_seq_cst)
-        LIFETIMEBOUND -> atomic_bitset & {
-        atomic::store(storage, elem_t{}, order);
-        return *this;
+        return bitset_t{atomic::fetch_and(
+            storage, static_cast<elem_t>(~(bit << pos)), order)};
     }
 
     auto
     reset(lsb_t lsb, msb_t msb,
           std::memory_order order = std::memory_order_seq_cst) -> bitset_t {
-        return set(lsb, msb, false, order);
+        auto const l = to_underlying(lsb);
+        auto const m = to_underlying(msb);
+        auto const shifted_value = bit_mask<elem_t>(m, l);
+        return bitset_t{atomic::fetch_and(storage, ~shifted_value, order)};
     }
 
     auto
     reset(lsb_t lsb, length_t len,
           std::memory_order order = std::memory_order_seq_cst) -> bitset_t {
-        return set(lsb, len, false, order);
+        auto const l = to_underlying(lsb);
+        auto const length = to_underlying(len);
+        return reset(lsb, static_cast<msb_t>(l + length - 1), order);
+    }
+
+    auto reset(std::memory_order order = std::memory_order_seq_cst)
+        LIFETIMEBOUND -> atomic_bitset & {
+        atomic::store(storage, elem_t{}, order);
+        return *this;
     }
 
     template <typename T>
@@ -191,6 +198,21 @@ class atomic_bitset {
             atomic::fetch_xor(storage, static_cast<elem_t>(bit << pos), order)};
     }
 
+    auto flip(lsb_t lsb, msb_t msb,
+              std::memory_order order = std::memory_order_seq_cst) -> bitset_t {
+        auto const l = to_underlying(lsb);
+        auto const m = to_underlying(msb);
+        auto const shifted_value = bit_mask<elem_t>(m, l);
+        return bitset_t{atomic::fetch_xor(storage, shifted_value, order)};
+    }
+
+    auto flip(lsb_t lsb, length_t len,
+              std::memory_order order = std::memory_order_seq_cst) -> bitset_t {
+        auto const l = to_underlying(lsb);
+        auto const length = to_underlying(len);
+        return flip(lsb, static_cast<msb_t>(l + length - 1), order);
+    }
+
     auto flip(std::memory_order order = std::memory_order_seq_cst) -> bitset_t {
         return bitset_t{atomic::fetch_xor(storage, mask, order)};
     }

test/atomic_bitset.cpp

@@ -355,11 +355,13 @@ TEMPLATE_TEST_CASE("reset returns the previous bitset", "[atomic_bitset]",
 TEMPLATE_TEST_CASE("flip returns the previous bitset", "[atomic_bitset]",
                    std::uint8_t, std::uint16_t, std::uint32_t, std::uint64_t) {
     using namespace stdx::literals;
-    auto bs = stdx::atomic_bitset<1, TestType>{0b1ul};
-    CHECK(bs.flip() == stdx::bitset<1, TestType>{0b1ul});
+    auto bs = stdx::atomic_bitset<8, TestType>{0b111ul};
+    CHECK(bs.flip(0) == stdx::bitset<8, TestType>{0b111ul});
     CHECK(not bs[0]);
-    CHECK(bs.flip(0) == stdx::bitset<1, TestType>{});
-    CHECK(bs[0]);
+    CHECK(bs.flip(1_lsb, 1_len) == stdx::bitset<8, TestType>{0b110ul});
+    CHECK(not bs[1]);
+    CHECK(bs.flip(2_lsb, 2_msb) == stdx::bitset<8, TestType>{0b100ul});
+    CHECK(not bs[2]);
 }
 
 TEST_CASE("atomic bitset is thread-safe", "[atomic_bitset]") {