Question

我希望以一种不会破坏性能的方式与较小的一个相关联。目前，我的应用程序在以下代码中花费了20％的cpu时间：

boost::dynamic_bitset<> encode(const std::vector<char>& data)
{
    boost::dynamic_bitset<> result;

    std::for_each(data.begin(), data.end(), [&](unsigned char symbol)
    {
        for(size_t n = 0; n < codes_[symbol].size(); ++n)
            result.push_back(codes_[symbol][n]); // codes_[symbol][n].size() avarage ~5 bits
    });
    return result;
}

我已经阅读了这个post提出了一个解决方案，遗憾的是，由于目标位集和源位集的大小之间的大小差异非常大，这对我不起作用。

有什么想法吗？

如果使用boost :: dynamic_bitset无法做到这一点，那么我会对其他建议持开放态度。

Answer 1

这是因为你继续使用push_back()，但事实上，你已经提前知道了这个尺寸。这意味着大量的冗余复制和重新分配。你应该先调整它的大小。此外，您不必push_back()每个值 - 您应该可以使用某种形式的insert()（我实际上并不知道它的确切界面，但我认为{{1 （）是一次插入整个目标矢量的名称），这应该会更好。

此外，您将append()保留为无符号长，但据我所知，您实际上只是将dynamic_bitset插入其中。改变这一点可以让你的生活更轻松。

我也很好奇unsigned char是什么类型 - 如果它是codes_你可以用map替换它，或者因为它最大限度地静态大小（256个条目是一个vector的最大值，一个静态数组。

Answer 2

我之前尝试过在性能代码中使用boost bitset并感到很失望。我稍微挖了一下，并得出结论我最好实现自己的位缓冲类，虽然我忘记了什么说服了我的提升类的细节永远不会很快（我确实得到了检查程序集）生产）。

我仍然不知道构建位缓冲区/位集/比特流的最快方法是什么，或者你想要的是什么。一位同事试图找出这个related question，但在撰写本文时，它仍在等待一个好的答案。

Answer 3

我写了自己的bitset类。我感谢任何改进建议。我将尝试研究SSE并查看是否有任何有用的东西。

使用非常粗略基准测试，我的性能提升了11倍，同时增加了6位。

class fast_bitset
{
public:
    typedef unsigned long block_type;
    static const size_t bits_per_block = sizeof(block_type)*8;

    fast_bitset() 
        : is_open_(true)
        , blocks_(1)
        , space_(blocks_.size()*bits_per_block){}

    void append(const fast_bitset& other)
    {
        assert(!other.is_open_);

        for(size_t n = 0; n < other.blocks_.size()-1; ++n)
            append(other.blocks_[n], bits_per_block);
        append(other.blocks_.back() >> other.space_, bits_per_block - other.space_);
    }

    void append(block_type value, size_t n_bits)
    {
        assert(is_open_);
        assert(n_bits < bits_per_block);

        if(space_ < n_bits)
        {
            blocks_.back() = blocks_.back() << space_;
            blocks_.back() = blocks_.back() | (value >> (n_bits - space_));
            blocks_.push_back(value);
            space_ = bits_per_block - (n_bits - space_);
        }
        else
        {
            blocks_.back() = blocks_.back() << n_bits;
            blocks_.back() = blocks_.back() | value;
            space_ -= n_bits;
        }
    }

    void push_back(bool bit)
    {
        append(bit, 1);
    }

    bool operator[](size_t index) const
    {
        assert(!is_open_);

        static const size_t high_bit = 1 << (bits_per_block-1);
        const size_t block_index = index / bits_per_block;
        const size_t bit_index = index % bits_per_block;
        const size_t bit_mask = high_bit >> bit_index;
        return blocks_[block_index] & bit_mask;
    }

    void close()
    {
        blocks_.back() = blocks_.back() << space_;
        is_open_ = false;
    }

    size_t size() const
    {
        return blocks_.size()*bits_per_block-space_;
    }

    const std::vector<block_type>& blocks() const {return blocks_;}

    class reader
    {
    public:
        reader(const fast_bitset& bitset) 
            : bitset_(bitset)
            , index_(0)
            , size_(bitset.size()){}
        bool next_bit(){return bitset_[index_++];}
        bool eof() const{return index_ >= size_;}
    private:
        const fast_bitset& bitset_;
        size_t index_;
        size_t size_;
    };

private:
    bool is_open_;
    std::vector<block_type> blocks_;
    size_t space_;
};

boost :: dynamic_bitset concat性能

3 个答案: