std::lower_bound slower for std::vector than std::map::find

我编写了一个类，作为顺序容器（std::vector/std::queue/std::list）的包装器，以具有std::map的接口，从而在使用少量小对象时提高性能。考虑到现有的算法，编码非常简单。这段代码显然是从我的完整代码中高度精简的，但显示了问题所在。

template <class key_, 
          class mapped_, 
          class traits_ = std::less<key_>,
          class undertype_ = std::vector<std::pair<key_,mapped_> >
         >
class associative
{
public:
    typedef traits_ key_compare;
    typedef key_ key_type;
    typedef mapped_ mapped_type;
    typedef std::pair<const key_type, mapped_type> value_type;
    typedef typename undertype_::allocator_type allocator_type;
    typedef typename allocator_type::template rebind<value_type>::other value_allocator_type;
    typedef typename undertype_::const_iterator const_iterator;
    class value_compare {
        key_compare pred_;
    public:
        inline value_compare(key_compare pred=key_compare()) : pred_(pred) {}
        inline bool operator()(const value_type& left, const value_type& right) const {return pred_(left.first,right.first);}
        inline bool operator()(const value_type& left, const key_type& right) const {return pred_(left.first,right);}
        inline bool operator()(const key_type& left, const value_type& right) const {return pred_(left,right.first);}
        inline bool operator()(const key_type& left, const key_type& right) const {return pred_(left,right);}
        inline key_compare key_comp( ) const {return pred_;}
    };
    class iterator  {
    public:       
        typedef typename value_allocator_type::difference_type difference_type;
        typedef typename value_allocator_type::value_type value_type;
        typedef typename value_allocator_type::reference reference;
        typedef typename value_allocator_type::pointer pointer;
        typedef std::bidirectional_iterator_tag iterator_category;
        inline iterator(const typename undertype_::iterator& rhs) : data(rhs) {}
    inline reference operator*() const { return reinterpret_cast<reference>(*data);}
        inline pointer operator->() const {return reinterpret_cast<pointer>(structure_dereference_operator(data));}
        operator const_iterator&() const {return data;}
    protected:
        typename undertype_::iterator data;
    };
    template<class input_iterator>
    inline associative(input_iterator first, input_iterator last) : internal_(first, last), comp_() 
    {if (std::is_sorted(internal_.begin(), internal_.end())==false) std::sort(internal_.begin(), internal_.end(), comp_);}
inline iterator find(const key_type& key) {
    iterator i = std::lower_bound(internal_.begin(), internal_.end(), key, comp_);
    return (comp_(key,*i) ? internal_.end() : i);
}
protected:
    undertype_ internal_;
    value_compare comp_;
};

SSCCEhttp://ideone.com/Ufn7r，完整代码位于http://ideone.com/MQr0Z（注意：作为IdeOne的结果时间非常不稳定，可能是由于服务器负载，并且没有清楚地显示有问题的结果）

我用std::string和POD进行了测试，POD从4到128字节，范围从8到2000个元素，MSVC10。

我预计（1）从一个范围内创建小对象，（2）随机插入/擦除少量小对象，以及（3）查找所有对象会有更高的性能。令人惊讶的是，对于所有测试，从一个范围内创建矢量的速度明显快于，对于随机擦除的速度更快，这取决于高达2048字节的大小（512个4字节对象或128个16字节对象等）。然而，最令人震惊的是，对于所有POD，使用std::lower_bound的std::vector比std::map::find慢。4字节和8字节POD的差异很小，但对于128字节POD，std::vector慢了36%！然而，对于std::string，std::vector平均快6%。

我觉得排序后的std::vector上的std::lower_bound应该优于std::map，因为它具有更好的缓存位置/更小的内存大小，而且由于map可能不完全平衡，或者在最坏的情况下它应该匹配std::map，但我想不出std::map应该更快的任何原因。我唯一的想法是谓词在某种程度上减慢了它的速度，但我不知道怎么做。所以问题是：排序的std::vector上的std::lower_bound怎么会比std::map（在MSVC10中）表现更好

[EDIT]我已经确认，std::vector<std::pair<4BYTEPOD,4BYTEPOD>>上的std::lower_bound使用的比较平均少于std::map<4BYTEPOD,4BYTEPOD>::find（0-0.25），但我的实现仍然慢了26%。

我在http://ideone.com/41iKt它去除了所有不需要的绒毛，并清楚地表明，经过分类的vector上的find比map慢约15%。