17 #ifndef __TBB_concurrent_vector_H 18 #define __TBB_concurrent_vector_H 20 #define __TBB_concurrent_vector_H_include_area 32 #include __TBB_STD_SWAP_HEADER 38 #if _MSC_VER==1500 && !__INTEL_COMPILER 40 #pragma warning( push ) 41 #pragma warning( disable: 4985 ) 44 #if _MSC_VER==1500 && !__INTEL_COMPILER 45 #pragma warning( pop ) 48 #if __TBB_INITIALIZER_LISTS_PRESENT 49 #include <initializer_list> 52 #if defined(_MSC_VER) && !defined(__INTEL_COMPILER) 54 #pragma warning (push) 56 #pragma warning (disable: 4267) 58 #pragma warning (disable: 4127) //warning C4127: conditional expression is constant 63 template<
typename T,
class A = cache_aligned_allocator<T> >
69 template<
typename Container,
typename Value>
78 std::memset( static_cast<void*>(array), 0, n_of_elements *
sizeof( T ) );
114 template<
typename argument_type>
118 T*
pointer()
const {
return static_cast<T*
>(
const_cast<void*
>(array)); }
138 tbb::internal::swap<relaxed>(array, rhs.
array);
146 template<memory_semantics M>
149 template<memory_semantics M>
154 template<memory_semantics M>
160 template<memory_semantics M>
163 "other overloads of store should be used for marking segment as not_used or allocation_failed" );
164 array.store<M>(allocated_segment_pointer);
203 my_early_size.store<
relaxed>(0);
204 my_first_block.store<
relaxed>(0);
237 __TBB_ASSERT(element_index,
"there should be no need to call " 238 "is_first_element_in_segment for 0th element" );
279 template<
typename Container,
typename Value>
293 template<
typename Container,
typename Value>
306 template<
typename C,
typename T>
309 template<
typename C,
typename T,
typename U>
312 template<
typename C,
typename T,
typename U>
315 template<
typename C,
typename T,
typename U>
318 template<
typename C,
typename U>
321 #if !__TBB_TEMPLATE_FRIENDS_BROKEN 322 template<
typename T,
class A>
329 my_vector(const_cast<Container*>(&vector)),
331 my_item(static_cast<Value*>(ptr))
339 my_vector(other.my_vector),
340 my_index(other.my_index),
341 my_item(other.my_item)
369 Value* item = my_item;
371 item = my_item = &my_vector->internal_subscript(my_index);
373 __TBB_ASSERT( item==&my_vector->internal_subscript(my_index),
"corrupt cache" );
377 return my_vector->internal_subscript(my_index+k);
383 size_t element_index = ++my_index;
399 __TBB_ASSERT( my_index>0,
"operator--() applied to iterator already at beginning of concurrent_vector" );
400 size_t element_index = my_index--;
436 template<
typename Container,
typename T>
441 template<
typename Container,
typename T,
typename U>
446 template<
typename Container,
typename T,
typename U>
451 template<
typename Container,
typename T,
typename U>
456 template<
typename Container,
typename T,
typename U>
461 template<
typename Container,
typename T,
typename U>
466 template<
typename Container,
typename T,
typename U>
471 template<
typename Container,
typename T,
typename U>
476 template<
typename T,
class A>
549 template<
typename T,
class A>
567 template<
typename C,
typename U>
587 #if !defined(_MSC_VER) || _CPPLIB_VER>=300 593 typedef std::reverse_iterator<iterator,T,T&,T*> reverse_iterator;
594 typedef std::reverse_iterator<const_iterator,T,const T&,const T*> const_reverse_iterator;
616 #if __TBB_INITIALIZER_LISTS_PRESENT 617 concurrent_vector(std::initializer_list<T> init_list,
const allocator_type &a = allocator_type())
623 internal_assign_iterators(init_list.begin(), init_list.end());
631 #endif //# __TBB_INITIALIZER_LISTS_PRESENT 647 #if __TBB_CPP11_RVALUE_REF_PRESENT 663 if (a == source.my_allocator) {
698 internal_resize( n,
sizeof(T), max_size(), NULL, &destroy_array, &initialize_array );
712 internal_resize( n,
sizeof(T), max_size(), static_cast<const void*>(&t), &destroy_array, &initialize_array_by );
727 internal_assign_range(first, last,
static_cast<is_integer_tag<std::numeric_limits<I>::is_integer
> *>(0) );
737 if(
this != &vector )
738 internal_assign(vector,
sizeof(T), &destroy_array, &assign_array, ©_array);
742 #if __TBB_CPP11_RVALUE_REF_PRESENT 746 __TBB_ASSERT(
this != &other,
"Move assignment to itself is prohibited ");
753 internal_assign(other,
sizeof(T), &destroy_array, &move_assign_array, &move_array);
763 if( static_cast<void*>(
this ) != static_cast<const void*>( &vector ) )
765 sizeof(T), &destroy_array, &assign_array, ©_array);
769 #if __TBB_INITIALIZER_LISTS_PRESENT 773 internal_assign_iterators(init_list.begin(), init_list.end());
776 #endif //#if __TBB_INITIALIZER_LISTS_PRESENT 789 iterator
grow_by( size_type delta, const_reference t ) {
790 return iterator(*
this, delta ?
internal_grow_by( delta,
sizeof(T), &initialize_array_by, static_cast<const void*>(&t) ) :
my_early_size.load());
796 typename std::iterator_traits<I>::difference_type delta = std::distance(first, last);
802 #if __TBB_INITIALIZER_LISTS_PRESENT 804 iterator
grow_by( std::initializer_list<T> init_list ) {
805 return grow_by( init_list.begin(), init_list.end() );
807 #endif //#if __TBB_INITIALIZER_LISTS_PRESENT 820 return iterator(*
this, m);
831 return iterator(*
this, m);
838 push_back_helper prolog(*
this);
839 new(prolog.internal_push_back_result()) T(item);
840 return prolog.return_iterator_and_dismiss();
843 #if __TBB_CPP11_RVALUE_REF_PRESENT 848 push_back_helper prolog(*
this);
849 new(prolog.internal_push_back_result()) T(
std::move(item));
850 return prolog.return_iterator_and_dismiss();
852 #if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT 855 template<
typename... Args>
858 push_back_helper prolog(*
this);
859 new(prolog.internal_push_back_result()) T(std::forward<Args>(args)...);
860 return prolog.return_iterator_and_dismiss();
862 #endif //__TBB_CPP11_VARIADIC_TEMPLATES_PRESENT 863 #endif //__TBB_CPP11_RVALUE_REF_PRESENT 868 return internal_subscript(index);
873 return internal_subscript(index);
877 reference
at( size_type index ) {
878 return internal_subscript_with_exceptions(index);
882 const_reference
at( size_type index )
const {
883 return internal_subscript_with_exceptions(index);
887 range_type
range(
size_t grainsize = 1 ) {
888 return range_type(
begin(),
end(), grainsize );
892 const_range_type
range(
size_t grainsize = 1 )
const {
893 return const_range_type(
begin(),
end(), grainsize );
902 return cp < sz ? cp : sz;
921 internal_resize( n,
sizeof(T), max_size(), NULL, &destroy_array, &initialize_array );
925 void resize( size_type n, const_reference t ) {
926 internal_resize( n,
sizeof(T), max_size(), static_cast<const void*>(&t), &destroy_array, &initialize_array_by );
930 void shrink_to_fit();
940 iterator
begin() {
return iterator(*
this,0);}
942 iterator
end() {
return iterator(*
this,
size());}
944 const_iterator
begin()
const {
return const_iterator(*
this,0);}
946 const_iterator
end()
const {
return const_iterator(*
this,
size());}
948 const_iterator
cbegin()
const {
return const_iterator(*
this,0);}
950 const_iterator
cend()
const {
return const_iterator(*
this,
size());}
952 reverse_iterator
rbegin() {
return reverse_iterator(
end());}
954 reverse_iterator
rend() {
return reverse_iterator(
begin());}
956 const_reverse_iterator
rbegin()
const {
return const_reverse_iterator(
end());}
958 const_reverse_iterator
rend()
const {
return const_reverse_iterator(
begin());}
960 const_reverse_iterator
crbegin()
const {
return const_reverse_iterator(
end());}
962 const_reverse_iterator
crend()
const {
return const_reverse_iterator(
begin());}
967 return (segment_value.template
pointer<T>())[0];
978 return internal_subscript(
size()-1 );
983 return internal_subscript(
size()-1 );
989 void assign(size_type n, const_reference t) {
991 internal_resize( n,
sizeof(T), max_size(), static_cast<const void*>(&t), &destroy_array, &initialize_array_by );
997 clear(); internal_assign_range( first, last,
static_cast<is_integer_tag<std::numeric_limits<I>::is_integer
> *>(0) );
1000 #if __TBB_INITIALIZER_LISTS_PRESENT 1001 void assign(std::initializer_list<T> init_list) {
1003 clear(); internal_assign_iterators( init_list.begin(), init_list.end());
1005 #endif //# __TBB_INITIALIZER_LISTS_PRESENT 1039 T& internal_subscript( size_type index )
const;
1042 T& internal_subscript_with_exceptions( size_type index )
const;
1046 internal_resize( n,
sizeof(T), max_size(), static_cast<const void*>(p), &destroy_array, p? &initialize_array_by : &initialize_array );
1061 internal_assign_n(static_cast<size_type>(first), &static_cast<T&>(last));
1066 internal_assign_iterators(first, last);
1070 void internal_assign_iterators(I first, I last);
1078 static void __TBB_EXPORTED_FUNC initialize_array_by(
void* begin,
const void* src, size_type n );
1083 #if __TBB_MOVE_IF_NOEXCEPT_PRESENT 1084 static void __TBB_EXPORTED_FUNC move_array_if_noexcept(
void* dst,
const void* src, size_type n );
1086 #endif //__TBB_MOVE_IF_NO_EXCEPT_PRESENT 1088 #if __TBB_CPP11_RVALUE_REF_PRESENT 1093 static void __TBB_EXPORTED_FUNC move_assign_array(
void* dst,
const void* src, size_type n );
1095 template<
typename Iterator>
1097 static void __TBB_EXPORTED_FUNC copy_range(
void* dst,
const void* p_type_erased_iterator, size_type n );
1113 static T*
as_pointer(
const void *src) {
return static_cast<T*
>(
const_cast<void *
>(src)); }
1116 : array(as_pointer(ptr)), n(ntrials), i(0) {}
1117 void init() {
for(; i < n; ++i)
new( &array[i] ) T(); }
1118 void init(
const void *src) {
for(; i < n; ++i)
new( &array[i] ) T(*as_const_pointer(src)); }
1119 void copy(
const void *src) {
for(; i < n; ++i)
new( &array[i] ) T(as_const_pointer(src)[i]); }
1120 void assign(
const void *src) {
for(; i < n; ++i) array[i] = as_const_pointer(src)[i]; }
1121 #if __TBB_CPP11_RVALUE_REF_PRESENT 1125 #if __TBB_MOVE_IF_NOEXCEPT_PRESENT 1126 void move_construct_if_noexcept(
const void *src) {
for(; i < n; ++i)
new( &array[i] ) T( std::move_if_noexcept(as_pointer(src)[i]) ); }
1127 #endif //__TBB_MOVE_IF_NOEXCEPT_PRESENT 1130 template<
class I>
void iterate(I &src) {
for(; i < n; ++i, ++src)
new( &array[i] ) T( *src ); }
1164 return iterator(v, k, ptr);
1169 #if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT 1171 template<
typename I,
1172 typename T =
typename std::iterator_traits<I>::value_type,
1178 template<
typename T,
typename A1,
typename A2>
1183 template<
typename T,
typename A = cache_aligned_allocator<T>
1188 #if defined(_MSC_VER) && !defined(__INTEL_COMPILER) 1189 #pragma warning (push) 1190 #pragma warning (disable: 4701) // potentially uninitialized local variable "old" 1192 template<
typename T,
class A>
1197 #if __TBB_MOVE_IF_NOEXCEPT_PRESENT 1198 &move_array_if_noexcept
1203 if(
internal_compact(
sizeof(T), &old, &destroy_array, copy_or_move_array ) )
1211 #if defined(_MSC_VER) && !defined(__INTEL_COMPILER) 1212 #pragma warning (pop) 1213 #endif // warning 4701 is back 1215 template<
typename T,
class A>
1218 while( k > first_block ) {
1233 template<
typename T,
class A>
1237 size_type j = index;
1247 return (( segment_value.
pointer<T>()))[j];
1250 template<
typename T,
class A>
1254 size_type j = index;
1265 return (segment_value.
pointer<T>())[j];
1268 template<
typename T,
class A>
template<
class I>
1271 size_type n = std::distance(first, last);
1280 loop.iterate(first);
1283 else { ++k; sz <<= 1; }
1286 loop.iterate(first);
1289 template<
typename T,
class A>
1291 internal_loop_guide loop(n, begin); loop.init();
1294 template<
typename T,
class A>
1296 internal_loop_guide loop(n, begin); loop.init(src);
1299 template<
typename T,
class A>
1301 internal_loop_guide loop(n, dst); loop.copy(src);
1304 #if __TBB_CPP11_RVALUE_REF_PRESENT 1305 template<
typename T,
class A>
1307 internal_loop_guide loop(n, dst); loop.move_construct(src);
1309 template<
typename T,
class A>
1311 internal_loop_guide loop(n, dst); loop.move_assign(src);
1315 #if __TBB_MOVE_IF_NOEXCEPT_PRESENT 1316 template<
typename T,
class A>
1318 internal_loop_guide loop(n, dst); loop.move_construct_if_noexcept(src);
1320 #endif //__TBB_MOVE_IF_NOEXCEPT_PRESENT 1322 template<
typename T,
class A>
1323 template<
typename I>
1325 internal_loop_guide loop(n, dst);
1326 loop.iterate( *(static_cast<I*>(const_cast<void*>(p_type_erased_iterator))) );
1329 template<
typename T,
class A>
1331 internal_loop_guide loop(n, dst); loop.assign(src);
1334 #if defined(_MSC_VER) && !defined(__INTEL_COMPILER) 1336 #pragma warning (push) 1337 #pragma warning (disable: 4189) 1339 template<
typename T,
class A>
1341 T* array =
static_cast<T*
>(
begin);
1342 for( size_type j=n; j>0; --j )
1345 #if defined(_MSC_VER) && !defined(__INTEL_COMPILER) 1346 #pragma warning (pop) 1347 #endif // warning 4189 is back 1350 template<
typename T,
class A1,
class A2>
1354 if(a.
size() != b.
size())
return false;
1357 for(; i != a.
end(); ++i, ++j)
1358 if( !(*i == *j) )
return false;
1362 template<
typename T,
class A1,
class A2>
1364 {
return !(a == b); }
1366 template<
typename T,
class A1,
class A2>
1368 {
return (std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end())); }
1370 template<
typename T,
class A1,
class A2>
1374 template<
typename T,
class A1,
class A2>
1376 {
return !(b < a); }
1378 template<
typename T,
class A1,
class A2>
1380 {
return !(a < b); }
1382 template<
typename T,
class A>
1388 #if defined(_MSC_VER) && !defined(__INTEL_COMPILER) 1389 #pragma warning (pop) 1390 #endif // warning 4267,4127 are back 1393 #undef __TBB_concurrent_vector_H_include_area
vector_iterator(const Container &vector, size_t index, void *ptr=0)
void internal_assign_range(I first, I last, is_integer_tag< false > *)
inline proxy assign by iterators
void swap(segment_t &rhs)
const internal::concurrent_vector_base_v3 & internal_vector_base() const
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp end
static void __TBB_EXPORTED_FUNC copy_range(void *dst, const void *p_type_erased_iterator, size_type n)
Copy-construct n instances of T, starting at "dst" by iterator range of [p_type_erased_iterator, p_type_erased_iterator+n).
concurrent_vector_base_v3 concurrent_vector_base
iterator return_iterator_and_dismiss()
void store(void *allocated_segment_pointer) __TBB_NOEXCEPT(true)
allocator_type get_allocator() const
return allocator object
void shrink_to_fit()
Optimize memory usage and fragmentation.
iterator grow_by(I first, I last)
internal::vector_iterator< concurrent_vector, const T > const_iterator
std::random_access_iterator_tag iterator_category
vector_iterator operator++(int)
Post increment.
__TBB_EXPORTED_METHOD ~concurrent_vector_base_v3()
const_reference operator[](size_type index) const
Get const reference to element at given index.
void __TBB_EXPORTED_METHOD internal_copy(const concurrent_vector_base_v3 &src, size_type element_size, internal_array_op2 copy)
segment_t my_storage[pointers_per_short_table]
embedded storage of segment pointers
friend bool operator==(segment_value_t const &lhs, segment_allocated)
iterator emplace_back(Args &&... args)
Push item, create item "in place" with provided arguments.
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t new_size
void internal_grow(size_type start, size_type finish, size_type element_size, internal_array_op2 init, const void *src)
concurrent_vector(const concurrent_vector< T, M > &vector, const allocator_type &a=allocator_type())
Copying constructor for vector with different allocator type.
static void __TBB_EXPORTED_FUNC copy_array(void *dst, const void *src, size_type n)
Copy-construct n instances of T by copying single element pointed to by src, starting at "dst"...
static void * internal_allocator(internal::concurrent_vector_base_v3 &vb, size_t k)
Allocate k items.
vector_iterator< Container, T > operator+(ptrdiff_t offset, const vector_iterator< Container, T > &v)
bool is_power_of_two_at_least(argument_integer_type arg, power2_integer_type power2)
A function to determine if arg is a power of 2 at least as big as another power of 2...
pointer internal_push_back_result()
const_reverse_iterator crbegin() const
reverse start const iterator
segment_t & operator=(segment_t const &rhs)
tbb::internal::allocator_rebind< A, T >::type allocator_type
friend bool operator!=(segment_value_t const &lhs, argument_type arg)
friend class vector_iterator
concurrent_vector_base_v3()
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp begin
void store(segment_allocation_failed)
friend bool operator==(segment_value_t const &lhs, segment_allocation_failed)
internal_loop_guide(size_type ntrials, void *ptr)
reference operator[](size_type index)
Get reference to element at given index.
friend void enforce_segment_allocated(segment_value_t const &s, internal::exception_id exception=eid_bad_last_alloc)
vector_iterator operator+(ptrdiff_t offset) const
auto last(Container &c) -> decltype(begin(c))
Value & operator*() const
Value * operator->() const
element_construction_guard(pointer an_element)
generic_range_type(const generic_range_type< U > &r)
internal::concurrent_vector_base_v3::size_type size_type
atomic< size_type > my_first_block
count of segments in the first block
vector_iterator operator--(int)
Post decrement.
Base class for types that should not be copied or assigned.
segment_index_t __TBB_EXPORTED_METHOD internal_clear(internal_array_op1 destroy)
void assign(const void *src)
const_iterator end() const
end const iterator
concurrent_vector(const concurrent_vector &vector, const allocator_type &a=allocator_type())
Copying constructor.
vector_iterator operator-(ptrdiff_t offset) const
concurrent_vector & operator=(const concurrent_vector< T, M > &vector)
Assignment for vector with different allocator type.
iterator end()
end iterator
void reserve(size_type n)
Allocate enough space to grow to size n without having to allocate more memory later.
size_type __TBB_EXPORTED_METHOD internal_capacity() const
reverse_iterator rend()
reverse end iterator
generic_range_type(generic_range_type &r, split)
const_reference front() const
the first item const
void move_construct(const void *src)
allocator_base(const allocator_type &a=allocator_type())
iterator grow_to_at_least(size_type n, const_reference t)
Container * my_vector
concurrent_vector over which we are iterating.
void resize(size_type n, const_reference t)
Resize the vector, copy t for new elements. Not thread-safe.
iterator push_back(const_reference item)
Push item.
const_iterator cend() const
end const iterator
Meets requirements of a forward iterator for STL and a Value for a blocked_range.*/.
vector_iterator & operator-=(ptrdiff_t offset)
static segment_index_t segment_index_of(size_type index)
allocator_type my_allocator
static void __TBB_EXPORTED_FUNC initialize_array_by(void *begin, const void *src, size_type n)
Copy-construct n instances of T, starting at "begin".
const_reference at(size_type index) const
Get const reference to element at given index. Throws exceptions on errors.
void *__TBB_EXPORTED_METHOD internal_compact(size_type element_size, void *table, internal_array_op1 destroy, internal_array_op2 copy)
void __TBB_EXPORTED_METHOD internal_swap(concurrent_vector_base_v3 &v)
auto first(Container &c) -> decltype(begin(c))
void move_assign(const void *src)
reference back()
the last item
T & internal_subscript_with_exceptions(size_type index) const
Get reference to element at given index with errors checks.
segment_index_t first_block
static void __TBB_EXPORTED_FUNC move_array(void *dst, const void *src, size_type n)
Move-construct n instances of T, starting at "dst" by copying according element of src array...
void handle_unconstructed_elements(T *array, size_t n_of_elements)
Exception helper function.
Value & operator[](ptrdiff_t k) const
const_iterator cbegin() const
start const iterator
static void *const vector_allocation_error_flag
Bad allocation marker.
#define __TBB_NOEXCEPT(expression)
void __TBB_EXPORTED_METHOD internal_throw_exception(size_type) const
Obsolete.
concurrent_vector(const allocator_type &a=allocator_type())
Construct empty vector.
const_reverse_iterator crend() const
reverse end const iterator
void *(* vector_allocator_ptr)(concurrent_vector_base_v3 &, size_t)
allocator function pointer
atomic< segment_t * > my_segment
Pointer to the segments table.
size_t my_index
Index into the vector.
void move(tbb_thread &t1, tbb_thread &t2)
void resize(size_type n)
Resize the vector. Not thread-safe.
void swap(concurrent_vector &vector)
swap two instances
void internal_assign_range(I first, I last, is_integer_tag< true > *)
assign integer items by copying when arguments are treated as iterators. See C++ Standard 2003 23...
atomic< size_type > my_early_size
Requested size of vector.
void __TBB_EXPORTED_METHOD internal_resize(size_type n, size_type element_size, size_type max_size, const void *src, internal_array_op1 destroy, internal_array_op2 init)
ptrdiff_t operator-(const vector_iterator< Container, T > &i, const vector_iterator< Container, U > &j)
iterator grow_to_at_least(size_type n)
Append minimal sequence of elements such that size()>=n.
~concurrent_vector()
Clear and destroy vector.
void __TBB_EXPORTED_METHOD internal_reserve(size_type n, size_type element_size, size_type max_size)
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long value
Value * my_item
Caches my_vector->internal_subscript(my_index)
internal::allocator_base< T, A >::allocator_type allocator_type
void __TBB_EXPORTED_METHOD internal_grow_to_at_least(size_type new_size, size_type element_size, internal_array_op2 init, const void *src)
Deprecated entry point for backwards compatibility to TBB 2.1.
void(__TBB_EXPORTED_FUNC * internal_array_op2)(void *dst, const void *src, size_type n)
An operation on n-element destination array and n-element source array.
static const T * as_const_pointer(const void *ptr)
void const char const char int ITT_FORMAT __itt_group_sync s
#define __TBB_EXPORTED_FUNC
True/false function override helper.
Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5.
iterator grow_by(size_type delta)
Grow by "delta" elements.
iterator grow_by(size_type delta, const_reference t)
Grow by "delta" elements using copying constructor.
concurrent_vector(size_type n)
Construction with initial size specified by argument n.
concurrent_vector(concurrent_vector &&source)
Move constructor.
void internal_assign_iterators(I first, I last)
assign by iterators
Number of slots for segment pointers inside the class.
element_construction_guard g
vector_iterator()
Default constructor.
static size_type segment_size(segment_index_t k)
void throw_exception(exception_id eid)
Versionless convenience wrapper for throw_exception_v4()
bool operator>=(const vector_iterator< Container, T > &i, const vector_iterator< Container, U > &j)
reference at(size_type index)
Get reference to element at given index. Throws exceptions on errors.
friend bool operator==(segment_value_t const &lhs, segment_not_used)
reverse_iterator rbegin()
reverse start iterator
vector_iterator & operator++()
Pre increment.
segment_value_t load() const
void internal_free_segments(segment_t table[], segment_index_t k, segment_index_t first_block)
Free k segments from table.
const_range_type range(size_t grainsize=1) const
Get const range for iterating with parallel algorithms.
vector_iterator(const vector_iterator< Container, typename Container::value_type > &other)
static segment_index_t segment_base(segment_index_t k)
Concurrent vector container.
void *__TBB_EXPORTED_METHOD internal_push_back(size_type element_size, size_type &index)
void(__TBB_EXPORTED_FUNC * internal_array_op1)(void *begin, size_type n)
An operation on an n-element array starting at begin.
const_reverse_iterator rend() const
reverse end const iterator
segment_t(segment_t const &rhs)
static void __TBB_EXPORTED_FUNC initialize_array(void *begin, const void *, size_type n)
Construct n instances of T, starting at "begin".
static void __TBB_EXPORTED_FUNC move_assign_array(void *dst, const void *src, size_type n)
Move-assign (using operator=) n instances of T, starting at "dst" by assigning according element of s...
bool operator!=(const vector_iterator< Container, T > &i, const vector_iterator< Container, U > &j)
size_type capacity() const
Maximum size to which array can grow without allocating more memory. Concurrent allocations are not i...
generic_range_type< const_iterator > const_range_type
void assign(size_type n, const_reference t)
assign n items by copying t item
size_type size() const
Return size of vector. It may include elements under construction.
std::reverse_iterator< iterator > reverse_iterator
segment_t table[pointers_per_long_table]
bool operator==(const vector_iterator< Container, T > &i, const vector_iterator< Container, U > &j)
Internal structure for compact()
size_type __TBB_EXPORTED_METHOD internal_grow_by(size_type delta, size_type element_size, internal_array_op2 init, const void *src)
A range over which to iterate.
bool empty() const
Return false if vector is not empty or has elements under construction at least.
range_type range(size_t grainsize=1)
Get range for iterating with parallel algorithms.
intptr_t __TBB_Log2(uintptr_t x)
size_type __TBB_EXPORTED_METHOD internal_grow_to_at_least_with_result(size_type new_size, size_type element_size, internal_array_op2 init, const void *src)
vector_iterator & operator=(const vector_iterator< Container, typename Container::value_type > &other)
concurrent_vector(size_type n, const_reference t, const allocator_type &a=allocator_type())
Construction with initial size specified by argument n, initialization by copying of t...
static void __TBB_EXPORTED_FUNC destroy_array(void *begin, size_type n)
Destroy n instances of T, starting at "begin".
ptrdiff_t difference_type
Base class of concurrent vector implementation.
void assign(I first, I last)
assign range [first, last)
push_back_helper(concurrent_vector &vector)
allocator_traits< Alloc >::template rebind_alloc< T >::other type
iterator begin()
start iterator
Dummy type that distinguishes splitting constructor from copy constructor.
#define __TBB_EXPORTED_METHOD
vector_iterator & operator+=(ptrdiff_t offset)
void init(const void *src)
void copy(const void *src)
bool operator>(const vector_iterator< Container, T > &i, const vector_iterator< Container, U > &j)
static T * as_pointer(const void *src)
~element_construction_guard()
static void __TBB_EXPORTED_FUNC assign_array(void *dst, const void *src, size_type n)
Assign (using operator=) n instances of T, starting at "dst" by assigning according element of src ar...
void store(segment_not_used)
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
concurrent_vector & operator=(const concurrent_vector &vector)
Assignment.
T & internal_subscript(size_type index) const
Get reference to element at given index.
void clear()
Clear container while keeping memory allocated.
segment_value_t(void *an_array)
concurrent_vector & operator=(concurrent_vector &&other)
Move assignment.
void allocator_move_assignment(MyAlloc &my_allocator, OtherAlloc &other_allocator, traits_true_type)
concurrent_vector(I first, I last, const allocator_type &a=allocator_type())
Construction with copying iteration range and given allocator instance.
void __TBB_EXPORTED_METHOD internal_assign(const concurrent_vector_base_v3 &src, size_type element_size, internal_array_op1 destroy, internal_array_op2 assign, internal_array_op2 copy)
const_reference back() const
the last item const
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t size
size_type max_size() const
Upper bound on argument to reserve.
void const char const char int ITT_FORMAT __itt_group_sync p
const T & const_reference
vector_iterator & operator--()
Pre decrement.
internal::vector_iterator< concurrent_vector, T > iterator
friend void swap(segment_t &, segment_t &) __TBB_NOEXCEPT(true)
std::reverse_iterator< const_iterator > const_reverse_iterator
generic_range_type(I begin_, I end_, size_t grainsize_=1)
generic_range_type< iterator > range_type
iterator push_back(T &&item)
Push item, move-aware.
void allocator_swap(MyAlloc &my_allocator, OtherAlloc &other_allocator, traits_true_type)
static segment_index_t segment_base_index_of(segment_index_t &index)
reference front()
the first item
iterator grow_by(std::initializer_list< T > init_list)
const_iterator begin() const
start const iterator
concurrent_vector(concurrent_vector &&source, const allocator_type &a)
ptrdiff_t difference_type
const_reverse_iterator rbegin() const
reverse start const iterator
Exception-aware helper class for filling a segment by exception-danger operators of user class...
void internal_assign_n(size_type n, const_pointer p)
assign n items by copying t
ptrdiff_t difference_type
const T & const_reference
static bool is_first_element_in_segment(size_type element_index)