vector optimizations and disabled false GCC warning

Author: igaztanaga

bench/bench_vector.cpp

@@ -12,6 +12,10 @@
 //
 //////////////////////////////////////////////////////////////////////////////
 
+#ifndef LONG_BENCH
+//#define LONG_BENCH
+#endif
+
 #include <vector>
 #include <memory>    //std::allocator
 #include <boost/container/vector.hpp>
@@ -23,7 +27,9 @@ void run_containers(runner<IntType, Operation>& r)
 {
    //First registered container is the baseline (denominator).
    r.template add< std::vector<IntType, std::allocator<IntType> > >("std::vector");
-   r.template add< bc::vector<IntType, std::allocator<IntType> >  >("vector");
+   r.template add< bc::vector<IntType, std::allocator<IntType> >  >("vector(1.6x)");
+   typedef typename bc::vector_options < bc::growth_factor<bc::growth_factor_100> >::type growth_100_t;
+   r.template add< bc::vector<IntType, std::allocator<IntType>, growth_100_t> >("vector(2x)");
 }
 
 int main()

include/boost/container/detail/copy_move_algo.hpp

@@ -535,11 +535,22 @@ inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, F>::type
 {
    F back = r;
    BOOST_CONTAINER_TRY{
+      //GCC's value-range analysis issues a spurious -Wmaybe-uninitialized here
+      //when this copy-construct loop is inlined into a fixed-capacity container's
+      //(e.g. static_vector) copy constructor after a near-end single-element
+      //insert: it cannot prove the just-built trailing slot is initialized.
+#if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
       while (n) {
          --n;
          allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), *f);
          ++f; ++r;
       }
+#if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
+#pragma GCC diagnostic pop
+#endif
    }
    BOOST_CONTAINER_CATCH(...){
       for (; back != r; ++back){

include/boost/container/vector.hpp

@@ -1938,17 +1938,21 @@ class vector
    template<class ...Args>
    inline reference emplace_back(BOOST_FWD_REF(Args)...args)
    {
-      T* const p = this->priv_raw_end();
       if (BOOST_LIKELY(this->room_enough())){
-         //There is more memory, just construct a new object at the end
+         //There is more memory, just construct a new object at the end.
+         //Deriving the end pointer inside this branch (instead of before the
+         //room_enough() test, where the slow path would also use it) lets the
+         //optimizer fold 'start + size' into the store's addressing mode and
+         //keep size as the sole induction variable in append loops.
+         T* const p = this->priv_raw_end();
          allocator_traits_type::construct(this->m_holder.alloc(), p, ::boost::forward<Args>(args)...);
          ++this->m_holder.m_size;
          return *p;
       }
       else{
          typedef dtl::insert_emplace_proxy<allocator_type, Args...> proxy_t;
          return *this->priv_insert_forward_range_no_capacity
-            (p, 1, proxy_t(::boost::forward<Args>(args)...), alloc_version());
+            (this->priv_raw_end(), 1, proxy_t(::boost::forward<Args>(args)...), alloc_version());
       }
    }
 
@@ -2019,17 +2023,20 @@ class vector
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
    inline reference emplace_back(BOOST_MOVE_UREF##N)\
    {\
-      T* const p = this->priv_raw_end();\
       if (BOOST_LIKELY(this->room_enough())){\
+         /*Derive the end pointer inside this branch so the optimizer can fold*/\
+         /*'start + size' into the store and keep size as the sole induction*/\
+         /*variable in append loops (the slow path recomputes it).*/\
+         T* const p = this->priv_raw_end();\
          allocator_traits_type::construct (this->m_holder.alloc()\
-            , this->priv_raw_end() BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+            , p BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
          ++this->m_holder.m_size;\
          return *p;\
       }\
       else{\
          typedef dtl::insert_emplace_proxy_arg##N<allocator_type BOOST_MOVE_I##N BOOST_MOVE_TARG##N> proxy_t;\
          return *this->priv_insert_forward_range_no_capacity\
-            ( p, 1, proxy_t(BOOST_MOVE_FWD##N), alloc_version());\
+            ( this->priv_raw_end(), 1, proxy_t(BOOST_MOVE_FWD##N), alloc_version());\
       }\
    }\
    \
@@ -3335,8 +3342,12 @@ class vector
       //There is enough memory
       T* const old_finish = this->priv_raw_end();
       allocator_type & a = this->m_holder.alloc();
+      //Number of trailing elements [raw_pos, old_finish). Expressing the shift
+      //length against the end pointer (n_after - 1) lets the compiler bound and
+      //fold a near-end shift to inline moves instead of an out-of-line memmove.
+      const size_type n_after = size_type(old_finish - raw_pos);
 
-      if (old_finish == raw_pos){
+      if (!n_after){
          insert_range_proxy.uninitialized_copy_n_and_update(a, old_finish, 1);
          ++this->m_holder.m_size;
       }
@@ -3348,7 +3359,7 @@ class vector
          allocator_traits_type::construct(a, old_finish, ::boost::move(*before_old_finish));
          ++this->m_holder.m_size;
          //Copy previous to last objects to the initialized end
-         boost::container::move_backward(raw_pos, before_old_finish, old_finish);
+         boost::container::move_backward_n(before_old_finish, n_after - 1u, old_finish);
          //Insert new objects in the raw_pos
          insert_range_proxy.copy_n_and_update(a, raw_pos, 1);
       }