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)
63 template<
typename T,
class A = cache_aligned_allocator<T> >
64 class concurrent_vector;
69 template<
typename Container,
typename Value>
70 class vector_iterator;
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);
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))
399 __TBB_ASSERT(
my_index>0,
"operator--() applied to iterator already at beginning of concurrent_vector" );
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
616 #if __TBB_INITIALIZER_LISTS_PRESENT
647 #if __TBB_CPP11_RVALUE_REF_PRESENT
663 if (a == source.my_allocator) {
737 if(
this != &vector )
742 #if __TBB_CPP11_RVALUE_REF_PRESENT
746 __TBB_ASSERT(
this != &other,
"Move assignment to itself is prohibited ");
763 if(
static_cast<void*
>(
this ) !=
static_cast<const void*
>( &vector ) )
769 #if __TBB_INITIALIZER_LISTS_PRESENT
796 typename std::iterator_traits<I>::difference_type delta = std::distance(
first,
last);
802 #if __TBB_INITIALIZER_LISTS_PRESENT
805 return grow_by( init_list.begin(), init_list.end() );
843 #if __TBB_CPP11_RVALUE_REF_PRESENT
852 #if __TBB_CPP11_VARIADIC_TEMPLATES_PRESENT
855 template<
typename... Args>
902 return cp < sz ? cp : sz;
967 return (segment_value.template
pointer<T>())[0];
1000 #if __TBB_INITIALIZER_LISTS_PRESENT
1002 void assign(std::initializer_list<T> init_list) {
1083 #if __TBB_MOVE_IF_NOEXCEPT_PRESENT
1088 #if __TBB_CPP11_RVALUE_REF_PRESENT
1096 template<
typename Iterator>
1113 static T*
as_pointer(
const void *src) {
return static_cast<T*
>(
const_cast<void *
>(src)); }
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]) ); }
1130 template<
class I>
void iterate(I &src) {
for(;
i <
n; ++
i, ++src)
new( &
array[
i] ) T( *src ); }
1169 #if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
1171 template<
typename I,
1172 typename T =
typename std::iterator_traits<I>::value_type,
1173 typename A = cache_aligned_allocator<T>
1174 > concurrent_vector(I, I,
const A& = A())
1175 -> concurrent_vector<T, A>;
1178 template<
typename T,
typename A1,
typename A2>
1179 concurrent_vector(
const concurrent_vector<T, A1> &,
const A2 &)
1180 -> concurrent_vector<T, A2>;
1183 template<
typename T,
typename A = cache_aligned_allocator<T>
1184 > concurrent_vector(std::initializer_list<T>,
const A& = A())
1185 -> concurrent_vector<T, A>;
1188 #if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
1189 #pragma warning (push)
1190 #pragma warning (disable: 4701)
1192 template<
typename T,
class A>
1196 internal_array_op2 copy_or_move_array =
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 ) )
1204 internal_free_segments( old.
table, pointers_per_long_table, old.
first_block );
1211 #if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
1212 #pragma warning (pop)
1215 template<
typename T,
class A>
1218 while( k > first_block ) {
1223 this->my_allocator.deallocate( (segment_value.
pointer<T>()), segment_size(k) );
1229 this->my_allocator.deallocate( (segment_value.
pointer<T>()), segment_size(first_block) );
1233 template<
typename T,
class A>
1236 __TBB_ASSERT( index < my_early_size,
"index out of bounds" );
1239 __TBB_ASSERT( my_segment.load<
acquire>() != my_storage || k < pointers_per_short_table,
"index is being allocated" );
1244 segment_value_t segment_value = my_segment[k].template load<relaxed>();
1247 return (( segment_value.
pointer<T>()))[j];
1250 template<
typename T,
class A>
1252 if( index >= my_early_size )
1257 if( my_segment.load<
acquire>() == my_storage && k >= pointers_per_short_table )
1263 segment_value_t segment_value = my_segment[k].template load<relaxed>();
1265 return (segment_value.
pointer<T>())[j];
1268 template<
typename T,
class A>
template<
class I>
1273 internal_reserve(n,
sizeof(T), max_size());
1277 size_type sz = segment_size( my_first_block );
1282 if( !k ) k = my_first_block;
1283 else { ++k; sz <<= 1; }
1289 template<
typename T,
class A>
1294 template<
typename T,
class A>
1299 template<
typename T,
class A>
1304 #if __TBB_CPP11_RVALUE_REF_PRESENT
1305 template<
typename T,
class A>
1309 template<
typename T,
class A>
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);
1322 template<
typename T,
class A>
1323 template<
typename I>
1326 loop.
iterate( *(
static_cast<I*
>(
const_cast<void*
>(p_type_erased_iterator))) );
1329 template<
typename T,
class A>
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);
1345 #if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
1346 #pragma warning (pop)
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)
1393 #undef __TBB_concurrent_vector_H_include_area
#define __TBB_EXPORTED_FUNC
intptr_t __TBB_Log2(uintptr_t x)
#define __TBB_NOEXCEPT(expression)
#define __TBB_EXPORTED_METHOD
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
void const char const char int ITT_FORMAT __itt_group_sync s
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 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 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
void const char const char int ITT_FORMAT __itt_group_sync p
bool operator<(const concurrent_vector< T, A1 > &a, const concurrent_vector< T, A2 > &b)
void swap(concurrent_hash_map< Key, T, HashCompare, A > &a, concurrent_hash_map< Key, T, HashCompare, A > &b)
bool operator==(const cache_aligned_allocator< T > &, const cache_aligned_allocator< U > &)
bool operator>(const concurrent_vector< T, A1 > &a, const concurrent_vector< T, A2 > &b)
bool operator>=(const concurrent_vector< T, A1 > &a, const concurrent_vector< T, A2 > &b)
void move(tbb_thread &t1, tbb_thread &t2)
bool operator<=(const concurrent_vector< T, A1 > &a, const concurrent_vector< T, A2 > &b)
bool operator!=(const cache_aligned_allocator< T > &, const cache_aligned_allocator< U > &)
bool operator>=(const vector_iterator< Container, T > &i, const vector_iterator< Container, U > &j)
void allocator_swap(MyAlloc &my_allocator, OtherAlloc &other_allocator, traits_true_type)
static void *const vector_allocation_error_flag
Bad allocation marker.
void swap(atomic< T > &lhs, atomic< T > &rhs)
bool operator!=(const vector_iterator< Container, T > &i, const vector_iterator< Container, U > &j)
void handle_unconstructed_elements(T *array, size_t n_of_elements)
Exception helper function.
bool operator==(const vector_iterator< Container, T > &i, const vector_iterator< Container, U > &j)
void allocator_move_assignment(MyAlloc &my_allocator, OtherAlloc &other_allocator, traits_true_type)
bool operator<=(const vector_iterator< Container, T > &i, const vector_iterator< Container, U > &j)
ptrdiff_t operator-(const vector_iterator< Container, T > &i, const vector_iterator< Container, U > &j)
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)
concurrent_vector_base_v3 concurrent_vector_base
auto last(Container &c) -> decltype(begin(c))
@ eid_segment_range_error
auto first(Container &c) -> decltype(begin(c))
vector_iterator< Container, T > operator+(ptrdiff_t offset, const vector_iterator< Container, T > &v)
bool operator<(const vector_iterator< Container, T > &i, const vector_iterator< Container, U > &j)
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.
A range over which to iterate.
const_iterator begin() const
Beginning of range.
size_type grainsize() const
The grain size for this range.
const_iterator end() const
One past last value in range.
Concurrent vector container.
concurrent_vector(const concurrent_vector &vector, const allocator_type &a=allocator_type())
Copying constructor.
void reserve(size_type n)
Allocate enough space to grow to size n without having to allocate more memory later.
const_reverse_iterator crbegin() const
reverse start const iterator
concurrent_vector & operator=(concurrent_vector &&other)
Move assignment.
void internal_assign_range(I first, I last, is_integer_tag< false > *)
inline proxy assign by iterators
static void __TBB_EXPORTED_FUNC initialize_array(void *begin, const void *, size_type n)
Construct n instances of T, starting at "begin".
generic_range_type< const_iterator > const_range_type
std::reverse_iterator< iterator > reverse_iterator
const_iterator end() const
end const iterator
const_reference front() const
the first item const
ptrdiff_t difference_type
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.
reference operator[](size_type index)
Get reference to element at given index.
size_type size() const
Return size of vector. It may include elements under construction.
const_reverse_iterator rend() const
reverse end const iterator
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...
allocator_type get_allocator() const
return allocator object
const_reference back() const
the last item const
iterator grow_to_at_least(size_type n, const_reference t)
generic_range_type< iterator > range_type
void internal_free_segments(segment_t table[], segment_index_t k, segment_index_t first_block)
Free k segments from table.
internal::vector_iterator< concurrent_vector, T > iterator
void internal_assign_n(size_type n, const_pointer p)
assign n items by copying t
void clear()
Clear container while keeping memory allocated.
const_reference at(size_type index) const
Get const reference to element at given index. Throws exceptions on errors.
void assign(std::initializer_list< T > init_list)
assigns an initializer list
concurrent_vector(const allocator_type &a=allocator_type())
Construct empty vector.
const_iterator cend() const
end const iterator
const T & const_reference
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".
reverse_iterator rend()
reverse end iterator
reference at(size_type index)
Get reference to element at given index. Throws exceptions on errors.
void resize(size_type n)
Resize the vector. Not thread-safe.
static void __TBB_EXPORTED_FUNC destroy_array(void *begin, size_type n)
Destroy n instances of T, starting at "begin".
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,...
internal::allocator_base< T, A >::allocator_type allocator_type
const_iterator cbegin() const
start const iterator
void assign(I first, I last)
assign range [first, last)
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.
__TBB_DEPRECATED concurrent_vector & operator=(const concurrent_vector< T, M > &vector)
Assignment for vector with different allocator type.
concurrent_vector & operator=(std::initializer_list< T > init_list)
Assignment for initializer_list.
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,...
void swap(concurrent_vector &vector)
swap two instances
void assign(size_type n, const_reference t)
assign n items by copying t item
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....
const_reverse_iterator crend() const
reverse end const iterator
concurrent_vector & operator=(const concurrent_vector &vector)
Assignment.
void resize(size_type n, const_reference t)
Resize the vector, copy t for new elements. Not thread-safe.
iterator grow_by(std::initializer_list< T > init_list)
iterator emplace_back(Args &&... args)
Push item, create item "in place" with provided arguments.
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".
reverse_iterator rbegin()
reverse start iterator
reference front()
the first item
const_range_type range(size_t grainsize=1) const
Get const range for iterating with parallel algorithms.
iterator grow_by(size_type delta, const_reference t)
Grow by "delta" elements using copying constructor.
concurrent_vector(std::initializer_list< T > init_list, const allocator_type &a=allocator_type())
Constructor from initializer_list.
__TBB_DEPRECATED concurrent_vector(const concurrent_vector< T, M > &vector, const allocator_type &a=allocator_type())
Copying constructor for vector with different allocator type.
concurrent_vector(size_type n)
Construction with initial size specified by argument n.
const_reverse_iterator rbegin() const
reverse start const iterator
static void * internal_allocator(internal::concurrent_vector_base_v3 &vb, size_t k)
Allocate k items.
internal::vector_iterator< concurrent_vector, const T > const_iterator
iterator end()
end iterator
reference back()
the last item
concurrent_vector(concurrent_vector &&source)
Move constructor.
const_reference operator[](size_type index) const
Get const reference to element at given index.
iterator begin()
start iterator
T & internal_subscript(size_type index) const
Get reference to element at given index.
~concurrent_vector()
Clear and destroy vector.
iterator grow_by(size_type delta)
Grow by "delta" elements.
const internal::concurrent_vector_base_v3 & internal_vector_base() const
void shrink_to_fit()
Optimize memory usage and fragmentation.
T & internal_subscript_with_exceptions(size_type index) const
Get reference to element at given index with errors checks.
size_type capacity() const
Maximum size to which array can grow without allocating more memory. Concurrent allocations are not i...
iterator push_back(T &&item)
Push item, move-aware.
const_iterator begin() const
start const iterator
iterator grow_by(I first, I last)
size_type max_size() const
Upper bound on argument to reserve.
iterator push_back(const_reference item)
Push item.
internal::concurrent_vector_base_v3::size_type size_type
std::reverse_iterator< const_iterator > const_reverse_iterator
concurrent_vector(I first, I last, const allocator_type &a=allocator_type())
Construction with copying iteration range and given allocator instance.
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...
iterator grow_to_at_least(size_type n)
Append minimal sequence of elements such that size()>=n.
void internal_assign_iterators(I first, I last)
assign by iterators
concurrent_vector(concurrent_vector &&source, const allocator_type &a)
Meets requirements of a forward iterator for STL and a Value for a blocked_range.*/.
vector_iterator operator++(int)
Post increment.
vector_iterator operator--(int)
Post decrement.
vector_iterator & operator=(const vector_iterator< Container, typename Container::value_type > &other)
friend vector_iterator< C, T > operator+(ptrdiff_t offset, const vector_iterator< C, T > &v)
Value * operator->() const
Value & operator*() const
Value * my_item
Caches my_vector->internal_subscript(my_index)
vector_iterator operator+(ptrdiff_t offset) const
vector_iterator()
Default constructor.
vector_iterator & operator+=(ptrdiff_t offset)
vector_iterator & operator--()
Pre decrement.
vector_iterator(const vector_iterator< Container, typename Container::value_type > &other)
friend bool operator==(const vector_iterator< C, T > &i, const vector_iterator< C, U > &j)
std::random_access_iterator_tag iterator_category
friend bool operator<(const vector_iterator< C, T > &i, const vector_iterator< C, U > &j)
ptrdiff_t difference_type
vector_iterator & operator++()
Pre increment.
vector_iterator operator-(ptrdiff_t offset) const
size_t my_index
Index into the vector.
Container * my_vector
concurrent_vector over which we are iterating.
friend ptrdiff_t operator-(const vector_iterator< C, T > &i, const vector_iterator< C, U > &j)
Value & operator[](ptrdiff_t k) const
vector_iterator(const Container &vector, size_t index, void *ptr=0)
vector_iterator & operator-=(ptrdiff_t offset)
Base class of concurrent vector implementation.
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_throw_exception(size_type) const
Obsolete.
static segment_index_t segment_index_of(size_type index)
atomic< size_type > my_early_size
Requested size of vector.
void *(* vector_allocator_ptr)(concurrent_vector_base_v3 &, size_t)
allocator function pointer
static bool is_first_element_in_segment(size_type element_index)
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)
friend void swap(segment_t &, segment_t &) __TBB_NOEXCEPT(true)
void *__TBB_EXPORTED_METHOD internal_push_back(size_type element_size, size_type &index)
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.
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)
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)
void __TBB_EXPORTED_METHOD internal_swap(concurrent_vector_base_v3 &v)
void internal_grow(size_type start, size_type finish, size_type element_size, internal_array_op2 init, const void *src)
static size_type segment_size(segment_index_t k)
concurrent_vector_base_v3()
size_type __TBB_EXPORTED_METHOD internal_grow_by(size_type delta, size_type element_size, internal_array_op2 init, const void *src)
static segment_index_t segment_base(segment_index_t k)
segment_index_t __TBB_EXPORTED_METHOD internal_clear(internal_array_op1 destroy)
@ pointers_per_short_table
Number of slots for segment pointers inside the class.
@ pointers_per_long_table
@ default_initial_segments
static segment_index_t segment_base_index_of(segment_index_t &index)
atomic< segment_t * > my_segment
Pointer to the segments table.
__TBB_EXPORTED_METHOD ~concurrent_vector_base_v3()
void(__TBB_EXPORTED_FUNC * internal_array_op1)(void *begin, size_type n)
An operation on an n-element array starting at begin.
friend void enforce_segment_allocated(segment_value_t const &s, internal::exception_id exception=eid_bad_last_alloc)
atomic< size_type > my_first_block
count of segments in the first block
segment_t my_storage[pointers_per_short_table]
embedded storage of segment pointers
size_type __TBB_EXPORTED_METHOD internal_capacity() const
void __TBB_EXPORTED_METHOD internal_reserve(size_type n, size_type element_size, size_type max_size)
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_METHOD internal_copy(const concurrent_vector_base_v3 &src, size_type element_size, internal_array_op2 copy)
friend bool operator==(segment_value_t const &lhs, segment_not_used)
friend bool operator==(segment_value_t const &lhs, segment_allocated)
segment_value_t(void *an_array)
friend bool operator!=(segment_value_t const &lhs, argument_type arg)
friend bool operator==(segment_value_t const &lhs, segment_allocation_failed)
segment_value_t load() const
void store(segment_allocation_failed)
void store(void *allocated_segment_pointer) __TBB_NOEXCEPT(true)
void swap(segment_t &rhs)
void store(segment_not_used)
segment_t & operator=(segment_t const &rhs)
segment_t(segment_t const &rhs)
Internal structure for compact()
segment_t table[pointers_per_long_table]
segment_index_t first_block
allocator_type my_allocator
allocator_base(const allocator_type &a=allocator_type())
tbb::internal::allocator_rebind< A, T >::type allocator_type
ptrdiff_t difference_type
const T & const_reference
generic_range_type(const generic_range_type< U > &r)
generic_range_type(I begin_, I end_, size_t grainsize_=1)
generic_range_type(generic_range_type &r, split)
True/false function override helper.
Exception-aware helper class for filling a segment by exception-danger operators of user class.
internal_loop_guide(size_type ntrials, void *ptr)
void move_construct(const void *src)
static T * as_pointer(const void *src)
void init(const void *src)
void assign(const void *src)
void copy(const void *src)
void move_assign(const void *src)
static const T * as_const_pointer(const void *ptr)
element_construction_guard g
iterator return_iterator_and_dismiss()
push_back_helper(concurrent_vector &vector)
pointer internal_push_back_result()
~element_construction_guard()
element_construction_guard(pointer an_element)
allocator_traits< Alloc >::template rebind_alloc< T >::other type
Base class for types that should not be copied or assigned.
Dummy type that distinguishes splitting constructor from copy constructor.