boostorg/container
1
0
Fork 1
mirror of https://github.com/boostorg/container.git synced 2025-08-02 22:14:26 +02:00
Code Issues Packages Projects Releases Wiki Activity

Updated range insertion code for enhanced performance.

Browse Source
This commit is contained in:
Ion Gaztañaga
2014-09-17 21:51:38 +02:00
parent f213f55f20
commit 0ccf576872
2 changed files with 131 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

164
include/boost/container/detail/flat_tree.hpp
View File

@@ -37,6 +37,7 @@
#include <boost/intrusive/pointer_traits.hpp>
#endif
#include <boost/aligned_storage.hpp>
#include <boost/move/make_unique.hpp>
namespace boost {
@@ -466,47 +467,7 @@ class flat_tree
>::type * = 0
#endif
)
{
size_type len = static_cast<size_type>(std::distance(first, last));
const size_type BurstSize = 16;
size_type positions[BurstSize];
//Prereserve all memory so that iterators are not invalidated
this->reserve(this->size()+len);
const const_iterator b(this->cbegin());
const_iterator pos(b);
//Loop in burst sizes
bool back_insert = false;
while(len && !back_insert){
size_type burst = len < BurstSize ? len : BurstSize;
const const_iterator ce(this->cend());
for(size_type i = 0; i != burst; ++i){
//Get the insertion position for each key, use std::iterator_traits<BidirIt>::value_type
//because it can be different from container::value_type
//(e.g. conversion between std::pair<A, B> -> boost::container::pair<A, B>
const typename std::iterator_traits<BidirIt>::value_type & val = *first;
pos = const_cast<const flat_tree&>(*this).priv_upper_bound(pos, ce, KeyOfValue()(val));
if(pos == this->cend()){ //this element and the remaining should be back inserted
burst = i;
back_insert = true;
break;
}
else{
positions[i] = static_cast<size_type>(pos - b);
++first;
--len;
}
}
//Insert all in a single step in the precalculated positions
this->m_data.m_vect.insert_ordered_at(burst, positions + burst, first);
//Next search position updated, iterator still valid because we've preserved the vector
pos += burst;
}
if(first != last){
//The remaining range should be back inserted
this->m_data.m_vect.insert(this->m_data.m_vect.cend(), len, first, last);
}
}
{ this->priv_insert_ordered_range(false, first, last); }
template <class InIt>
void insert_unique(ordered_unique_range_t, InIt first, InIt last
@@ -534,61 +495,7 @@ class flat_tree
>::type * = 0
#endif
)
{
size_type len = static_cast<size_type>(std::distance(first, last));
const size_type BurstSize = 16;
size_type positions[BurstSize];
size_type skips[BurstSize];
//Prereserve all memory so that iterators are not invalidated
this->reserve(this->size()+len);
const const_iterator b(this->cbegin());
const_iterator pos(b);
const value_compare &val_cmp = this->m_data;
skips[0u] = 0u;
//Loop in burst sizes
bool back_insert = false;
while(len && !back_insert){
const size_type burst = len < BurstSize ? len : BurstSize;
size_type unique_burst = 0u;
const const_iterator ce(this->cend());
while(unique_burst < burst && len > 0){
//Get the insertion position for each key, use std::iterator_traits<BidirIt>::value_type
//because it can be different from container::value_type
//(e.g. conversion between std::pair<A, B> -> boost::container::pair<A, B>
const typename std::iterator_traits<BidirIt>::value_type & val = *first;
pos = const_cast<const flat_tree&>(*this).priv_lower_bound(pos, ce, KeyOfValue()(val));
//Check if already present
if (pos != ce){
++first;
--len;
if(!val_cmp(val, *pos)){
if(unique_burst > 0){
++skips[unique_burst-1];
}
continue;
}
//If not present, calculate position
positions[unique_burst] = static_cast<size_type>(pos - b);
skips[unique_burst++] = 0u;
}
else{ //this element and the remaining should be back inserted
back_insert = true;
break;
}
}
if(unique_burst){
//Insert all in a single step in the precalculated positions
this->m_data.m_vect.insert_ordered_at(unique_burst, positions + unique_burst, skips + unique_burst, first);
//Next search position updated, iterator still valid because we've preserved the vector
pos += unique_burst;
}
}
if(first != last){
//The remaining range should be back inserted
this->m_data.m_vect.insert(this->m_data.m_vect.cend(), len, first, last);
}
}
{ this->priv_insert_ordered_range(true, first, last); }
#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
@@ -1023,6 +930,71 @@ class flat_tree
++pos;
}
}
template <class BidirIt>
void priv_insert_ordered_range(const bool unique_values, BidirIt first, BidirIt last)
{
size_type len = static_cast<size_type>(std::distance(first, last));
//Prereserve all memory so that iterators are not invalidated
this->reserve(this->size()+len);
//Auxiliary data for insertion positions.
const size_type BurstSize = len;
const ::boost::movelib::unique_ptr<size_type[]> positions =
::boost::movelib::make_unique_definit<size_type[]>(BurstSize);
const const_iterator b(this->cbegin());
const const_iterator ce(this->cend());
const_iterator pos(b);
const value_compare &val_cmp = this->m_data;
//Loop in burst sizes
bool back_insert = false;
while(len && !back_insert){
const size_type burst = len < BurstSize ? len : BurstSize;
size_type unique_burst = 0u;
size_type checked = 0;
for(; checked != burst; ++checked){
//Get the insertion position for each key, use std::iterator_traits<BidirIt>::value_type
//because it can be different from container::value_type
//(e.g. conversion between std::pair<A, B> -> boost::container::pair<A, B>
const typename std::iterator_traits<BidirIt>::value_type & val = *first;
pos = const_cast<const flat_tree&>(*this).priv_lower_bound(pos, ce, KeyOfValue()(val));
//Check if already present
if (pos != ce){
++first;
--len;
positions[checked] = (unique_values && !val_cmp(val, *pos)) ?
size_type(-1) : (++unique_burst, static_cast<size_type>(pos - b));
}
else{ //this element and the remaining should be back inserted
back_insert = true;
break;
}
}
if(unique_burst){
//Insert all in a single step in the precalculated positions
this->m_data.m_vect.insert_ordered_at(unique_burst, positions.get() + checked, first);
//Next search position updated, iterator still valid because we've preserved the vector
pos += unique_burst;
}
}
//The remaining range should be back inserted
if(unique_values){
while(len--){
BidirIt next(first);
++next;
if(next == last || val_cmp(*first, *next)){
this->m_data.m_vect.push_back(*first);
}
first = next;
}
BOOST_ASSERT(first == last);
}
else{
BOOST_ASSERT(size_type(std::distance(first, last)) == len);
if(len)
this->m_data.m_vect.insert(this->m_data.m_vect.cend(), len, first, last);
}
}
};
} //namespace container_detail {

64
test/flat_set_test.cpp
View File

@@ -322,12 +322,74 @@ bool flat_tree_ordered_insertion_test()
//Re-re-insertion of even
std::set<int> int_even_set;
for(std::size_t i = 0; i < NumElements; i+=2){
int_set.insert(static_cast<int>(i));
int_even_set.insert(static_cast<int>(i));
}
fset.insert(ordered_unique_range, int_even_set.begin(), int_even_set.end());
int_set4.insert(int_even_set.begin(), int_even_set.end());
if(!CheckEqualContainers(&int_set4, &fset))
return false;
//Partial Re-re-insertion of even
int_even_set.clear();
for(std::size_t i = 0; i < NumElements; i+=4){
int_even_set.insert(static_cast<int>(i));
}
fset.clear();
int_set4.clear();
//insert 0,4,8,12...
fset.insert(ordered_unique_range, int_even_set.begin(), int_even_set.end());
int_set4.insert(int_even_set.begin(), int_even_set.end());
if(!CheckEqualContainers(&int_set4, &fset))
return false;
for(std::size_t i = 2; i < NumElements; i+=4){
int_even_set.insert(static_cast<int>(i));
}
//insert 0,2,4,6,8,10,12...
fset.insert(ordered_unique_range, int_even_set.begin(), int_even_set.end());
int_set4.insert(int_even_set.begin(), int_even_set.end());
if(!CheckEqualContainers(&int_set4, &fset))
return false;
int_even_set.clear();
for(std::size_t i = 0; i < NumElements; i+=8){
int_even_set.insert(static_cast<int>(i));
}
fset.clear();
int_set4.clear();
//insert 0,8,16...
fset.insert(ordered_unique_range, int_even_set.begin(), int_even_set.end());
int_set4.insert(int_even_set.begin(), int_even_set.end());
if(!CheckEqualContainers(&int_set4, &fset))
return false;
for(std::size_t i = 0; i < NumElements; i+=2){
int_even_set.insert(static_cast<int>(i));
}
//insert 0,2,4,6,8,10,12...
fset.insert(ordered_unique_range, int_even_set.begin(), int_even_set.end());
int_set4.insert(int_even_set.begin(), int_even_set.end());
if(!CheckEqualContainers(&int_set4, &fset))
return false;
int_even_set.clear();
for(std::size_t i = 0; i < NumElements; i+=8){
int_even_set.insert(static_cast<int>(i));
int_even_set.insert(static_cast<int>(i+2));
}
int_even_set.insert(static_cast<int>(NumElements-2));
fset.clear();
int_set4.clear();
//insert 0,2,8,10...
fset.insert(ordered_unique_range, int_even_set.begin(), int_even_set.end());
int_set4.insert(int_even_set.begin(), int_even_set.end());
if(!CheckEqualContainers(&int_set4, &fset))
return false;
for(std::size_t i = 0; i < NumElements; i+=2){
int_even_set.insert(static_cast<int>(i));
}
//insert 0,2,4,6,8,10,12...
fset.insert(ordered_unique_range, int_even_set.begin(), int_even_set.end());
int_set4.insert(int_even_set.begin(), int_even_set.end());
if(!CheckEqualContainers(&int_set4, &fset))
return false;
}
return true;