Question

我有一个非常大的位向量（数百万的＆＃34;存在＆＃34;位），其大小仅在运行时知道（即没有std::bitset），但在实际使用之前已知，因此可以预先分配容器。

此向量最初全为零，其中单个位以增量，稀疏和随机方式设置。我唯一使用这个容器的是直接随机访问 - 检查＆＃34;存在＆＃34; （没有STL）。在尝试了几个替代容器后，似乎std::vector<bool>非常适合我的需求（尽管存在概念问题）。

每隔一段时间我需要重置所有此向量中的位由于它太大了，我无法完全重置所有的元素。但是，我知道所有设置位的索引，所以我可以单独重置它们。

由于std::vector<bool>将bool表示为位，因此每次此类重置都涉及额外的移位和其他此类调整操作。

是否有（便携式）方式进行＆＃34;粗略＆＃34;，低精度，重置？
一个会重置我请求的位所属的整个整数，避免任何额外的额外操作？

Answer 1

方法1＆＃34;密集＆＃34; ：

如果你需要一个密集的＆＃34;容器我建议你使用vector和bitset的混合物。

我们将位存储为一组位集，因此我们可以在每个＆＃34; chunk＆＃34;上使用bitset::reset。重置所有。 DynamicBitset::resize可用于为正确的位数腾出空间。

class DynamicBitset
{
private:
    static const unsigned BITS_LEN = 64; // or 32, or more?
    typedef std::bitset<BITS_LEN> Bits;
    std::vector<Bits> data_;
public:
    DynamicBitset(size_t len=0) {
        resize(len);
    }
    // reset all bits to false
    void reset() {
        for(auto it=data_.begin(); it!=data_.end(); ++it) {
            it->reset(); // we can use the fast bitfield::reset :)
        }
    }
    // reset the whole bitset belonging to bit i
    void reset_approx(size_t i) {
        data_[i/BITS_LEN].reset();
    }
    // make room for len bits
    void resize(size_t len) {
        data_.resize(len/BITS_LEN + 1);
    }
    // access a bit
    Bits::reference operator[](size_t i) {
        size_t k = i/BITS_LEN;
        return data_[k][i-k*BITS_LEN];
    }
    bool operator[](size_t i) const {
        size_t k = i/BITS_LEN;
        return data_[k][i-k*BITS_LEN];
    }
};

方法2＆＃34;稀疏＆＃34; ：

如果只存储很少的位，您也可以混合使用map和bitset。

这里我们只有在至少有位设置时才存储块。这需要额外的访问位成本，因为我们需要查找具有std::map的{{1}}，但使用的内存要少得多。

此外，功能重置完全符合您在问题中所述的内容 - 它只会触及您设置位置的区域。

当你有很长的比特序列时，

O(log N)是一个很好的选择。 1000 ... 000100 ... 010，而不是0101000111010110。

SparseDynamicBitset

Answer 2

是否有（便携式）方式进行＆＃34;粗略＆＃34;，低精度，重置？一个会重置我请求的位所属的整数，避免任何额外的额外操作？

不，不。（不适用于该容器类型）

FWIW，我写了一个数据类型，它可以帮助你处理大型稀疏位集（你需要将它包装在一个创建它们数组等的外部类型中）。该类型为32位宽，并通过使用32位来跟踪1024位的开/关状态（最差情况=> 3位设置）存储指向vector<unsigned>的指针，或（通常）使用32位作为2位大小/计数和最多3个嵌入的10位设置位索引。当vector不需要时，这比std::bitset<>的存储密度提高了32倍，这有助于减少内存缓存未命中。

注意：大小成员 - in_use - 与vector*中的最低有效位对齐是至关重要的，这样任何合法的指针（至少会有4个）字节对齐）必须具有in_use值0.为32位应用程序编写uintptr_t == 32，但可以使用相同的概念创建64位版本;数据类型需要使用uintptr_t，因此它可以在需要时存储指向vector的指针，因此必须匹配32位或64位执行模式。

代码包含的测试显示随机操作对bitset和Bit_Packer_32的影响相同。

#include <iostream>
#include <bitset>
#include <vector>
#include <algorithm>
#include <set>

class Bit_Packer_32
{
    // Invariants:
    // - 0 bits set: u_ == p_ == a == b == c == 0
    // - 1 bit set:  in_use == 1, a meaningful, b == c == 0
    // - 2 bits set: in_use == 2, a & b meaningful, c == 0
    // - 3 bits set: in_use == 3, a & b & c meaningful
    // - >3 bits:    in_use == 0, p_ != 0
    // NOTE: differentiating 0 from >3 depends on a == b == c == 0 for former

  public:
    Bit_Packer_32() : u_(0) { }

    class Reference
    {
      public:
        Reference(Bit_Packer_32& p, size_t n) : p_(p), n_(n) { }

        Reference& operator=(bool b) { p_.set(n_, b); return *this; }
        operator bool() const { return p_[n_]; }

      private:
        Bit_Packer_32& p_;
        size_t n_;
    };

    Reference operator[](size_t n) { return Reference(*this, n); }

    void set(size_t n)
    {
        switch (in_use)
        {
          case 0:
            if (p_)
            {
               if (std::find(p_->begin(), p_->end(), n) == p_->end())
                   p_->push_back(n);
            }
            else
            { in_use = 1; a = n; }
            break;
          case 1: if (a != n) { in_use = 2; b = n; } break;
          case 2: if (a != n && b != n) { in_use = 3; c = n; } break;
          case 3: if (a == n || b == n || c == n) break;
                  V* p = new V(4);
                  (*p)[0] = a; (*p)[1] = b; (*p)[2] = c; (*p)[3] = n;
                  p_ = p;
        }
    }

    void reset(size_t n)
    {
        switch (in_use)
        {
          case 0:
            if (p_)
            {
                V::iterator i = std::find(p_->begin(), p_->end(), n);
                if (i != p_->end())
                {
                    p_->erase(i);
                    if (p_->size() == 3)
                    {
                        // faster to copy out w/o erase, but tedious
                        int p0 = (*p_)[0], p1 = (*p_)[1], p2 = (*p_)[2];
                        delete p_;
                        a = p0; b = p1; c = p2;
                        in_use = 3;
                    }
                }
            }
            break;

          case 1: if (a == n) { u_ = 0; /* in_use = a = 0 */ } break;
          case 2: if (a == n) { in_use = 1; a = b; b = 0; break; }
                  else if (b == n) { in_use = 1; b = 0; break; }
          case 3:      if (a == n) a = c;
                  else if (b == n) b = c;
                  else if (c == n) ;
                  else break;
                  in_use = 2;
                  c = 0;
        }
    }

    void reset_all()
    {
        if (in_use == 0) delete p_;
        u_ = 0;
    }

    size_t count() const { return in_use ? in_use : p_ ? p_->size() : 0; }

    void set(size_t n, bool b) { if (b) set(n); else reset(n); }

    bool operator[](size_t n) const
    {
        switch (in_use)
        {
          case 0:
            return p_ && std::find(p_->begin(), p_->end(), n) != p_->end();
          case 1: return n == a;
          case 2: return n == a || n == b;
          case 3: return n == a || n == b || n == c;
        }
    }

    // e.g. operate_on<std::bitset<1024>, Op_Set>()
    //      operate_on<std::set<unsigned>, Op_Insert>()
    //      operate_on<std::vector<unsigned>, Op_Push_Back>()
    template <typename T, typename Op>
    T operate_on(const Op& op = Op()) const
    {
        T result;
        switch (in_use)
        {
          case 0:
            if (p_)
                for (V::const_iterator i = p_->begin(); i != p_->end(); ++i)
                     op(result, *i);
            break;
          case 3: op(result, c);
          case 2: op(result, b);
          case 1: op(result, a);
        }
        return result;
    }

  private:
    union
    {
        uintptr_t u_;
        typedef std::vector<unsigned> V;
        V* p_;
        struct
        {
            unsigned in_use : 2;
            unsigned a : 10;
            unsigned b : 10;
            unsigned c : 10;
        };
    };
};

struct Op_Insert
{
    template <typename T, typename U>
    void operator()(T& t, const U& u) const { t.insert(u); }
};

struct Op_Set
{
    template <typename T, typename U>
    void operator()(T& t, const U& u) const { t.set(u); }
};

struct Op_Push_Back
{
    template <typename T, typename U>
    void operator()(T& t, const U& u) const { t.push_back(u); }
};

#define TEST(A, B, MSG) \
    do { \
        bool pass = (A) == (B); \
        if (pass) break; \
        std::cout << "@" << __LINE__ << ": (" #A " == " #B ") "; \
        std::cout << (pass ? "pass\n" : "FAIL\n"); \
        std::cout << "  (" << (A) << " ==\n"; \
        std::cout << "   " << (B) << ")\n"; \
        std::cout << MSG << std::endl; \
    } while (false)

template <size_t N>
std::set<unsigned> to_set(const std::bitset<N>& bs)
{
    std::set<unsigned> result;
    for (unsigned i = 0; i < N; ++i)
        if (bs[i]) result.insert(i);
    return result;
}

template <typename T>
std::ostream& operator<<(std::ostream& os, const std::set<T>& s)
{
    for (std::set<T>::const_iterator i = s.begin(); i != s.end(); ++i)
    {
        if (i != s.begin()) os << ' ';
        os << *i;
    }
    return os;
}

int main()
{
    TEST(sizeof(uintptr_t), 4, "designed for 32-bit uintptr_t");

    for (int i = 0; i < 100000; ++i)
    {
        Bit_Packer_32 bp;
        std::bitset<1024> bs;
        for (int j = 0; j < 1 + i % 10; ++j)
        {
            int n = rand() % 1024;
            int v = rand() % 2;
            bs[n] = v;
            bp[n] = v;
            // TEST(bp.get_bitset(), bs);
            TEST((bp.operate_on<std::set<unsigned>, Op_Insert>()), to_set(bs),
                 "j " << j << ", n " << n << ", v " << v);
        }
    }
}

Answer 3

不，没有可移植的方法，因为不需要使用位字段，只需要推荐。如果您想要移植，可能需要实现自己的移植，例如std::vector<uint8_t>或std::bitset。

快速std :: vector <bool>重置</bool>

3 个答案: