Intel(R) Threading Building Blocks Doxygen Documentation  version 4.2.3
tbb::concurrent_vector< T, A > Class Template Reference

Concurrent vector container. More...

#include <concurrent_vector.h>

Inheritance diagram for tbb::concurrent_vector< T, A >:
Collaboration diagram for tbb::concurrent_vector< T, A >:

Classes

class  generic_range_type
 
class  internal_loop_guide
 Exception-aware helper class for filling a segment by exception-danger operators of user class. More...
 
class  is_integer_tag
 True/false function override helper. More...
 
struct  push_back_helper
 

Public Types

typedef internal::concurrent_vector_base_v3::size_type size_type
 
typedef internal::allocator_base< T, A >::allocator_type allocator_type
 
typedef T value_type
 
typedef ptrdiff_t difference_type
 
typedef T & reference
 
typedef const T & const_reference
 
typedef T * pointer
 
typedef const T * const_pointer
 
typedef internal::vector_iterator< concurrent_vector, T > iterator
 
typedef internal::vector_iterator< concurrent_vector, const T > const_iterator
 
typedef std::reverse_iterator< iteratorreverse_iterator
 
typedef std::reverse_iterator< const_iteratorconst_reverse_iterator
 
typedef generic_range_type< iteratorrange_type
 
typedef generic_range_type< const_iteratorconst_range_type
 

Public Member Functions

 concurrent_vector (const allocator_type &a=allocator_type())
 Construct empty vector. More...
 
 concurrent_vector (std::initializer_list< T > init_list, const allocator_type &a=allocator_type())
 Constructor from initializer_list. More...
 
 concurrent_vector (const concurrent_vector &vector, const allocator_type &a=allocator_type())
 Copying constructor. More...
 
 concurrent_vector (concurrent_vector &&source)
 Move constructor. More...
 
 concurrent_vector (concurrent_vector &&source, const allocator_type &a)
 
template<class M >
 concurrent_vector (const concurrent_vector< T, M > &vector, const allocator_type &a=allocator_type())
 Copying constructor for vector with different allocator type. More...
 
 concurrent_vector (size_type n)
 Construction with initial size specified by argument n. More...
 
 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, and given allocator instance. More...
 
template<class I >
 concurrent_vector (I first, I last, const allocator_type &a=allocator_type())
 Construction with copying iteration range and given allocator instance. More...
 
concurrent_vectoroperator= (const concurrent_vector &vector)
 Assignment. More...
 
concurrent_vectoroperator= (concurrent_vector &&other)
 Move assignment. More...
 
template<class M >
concurrent_vectoroperator= (const concurrent_vector< T, M > &vector)
 Assignment for vector with different allocator type. More...
 
concurrent_vectoroperator= (std::initializer_list< T > init_list)
 Assignment for initializer_list. More...
 
iterator grow_by (size_type delta)
 Grow by "delta" elements. More...
 
iterator grow_by (size_type delta, const_reference t)
 Grow by "delta" elements using copying constructor. More...
 
template<typename I >
iterator grow_by (I first, I last)
 
iterator grow_by (std::initializer_list< T > init_list)
 
iterator grow_to_at_least (size_type n)
 Append minimal sequence of elements such that size()>=n. More...
 
iterator grow_to_at_least (size_type n, const_reference t)
 
iterator push_back (const_reference item)
 Push item. More...
 
iterator push_back (T &&item)
 Push item, move-aware. More...
 
template<typename... Args>
iterator emplace_back (Args &&... args)
 Push item, create item "in place" with provided arguments. More...
 
reference operator[] (size_type index)
 Get reference to element at given index. More...
 
const_reference operator[] (size_type index) const
 Get const reference to element at given index. More...
 
reference at (size_type index)
 Get reference to element at given index. Throws exceptions on errors. More...
 
const_reference at (size_type index) const
 Get const reference to element at given index. Throws exceptions on errors. More...
 
range_type range (size_t grainsize=1)
 Get range for iterating with parallel algorithms. More...
 
const_range_type range (size_t grainsize=1) const
 Get const range for iterating with parallel algorithms. More...
 
size_type size () const
 Return size of vector. It may include elements under construction. More...
 
bool empty () const
 Return false if vector is not empty or has elements under construction at least. More...
 
size_type capacity () const
 Maximum size to which array can grow without allocating more memory. Concurrent allocations are not included in the value. More...
 
void reserve (size_type n)
 Allocate enough space to grow to size n without having to allocate more memory later. More...
 
void resize (size_type n)
 Resize the vector. Not thread-safe. More...
 
void resize (size_type n, const_reference t)
 Resize the vector, copy t for new elements. Not thread-safe. More...
 
void shrink_to_fit ()
 Optimize memory usage and fragmentation. More...
 
size_type max_size () const
 Upper bound on argument to reserve. More...
 
iterator begin ()
 start iterator More...
 
iterator end ()
 end iterator More...
 
const_iterator begin () const
 start const iterator More...
 
const_iterator end () const
 end const iterator More...
 
const_iterator cbegin () const
 start const iterator More...
 
const_iterator cend () const
 end const iterator More...
 
reverse_iterator rbegin ()
 reverse start iterator More...
 
reverse_iterator rend ()
 reverse end iterator More...
 
const_reverse_iterator rbegin () const
 reverse start const iterator More...
 
const_reverse_iterator rend () const
 reverse end const iterator More...
 
const_reverse_iterator crbegin () const
 reverse start const iterator More...
 
const_reverse_iterator crend () const
 reverse end const iterator More...
 
reference front ()
 the first item More...
 
const_reference front () const
 the first item const More...
 
reference back ()
 the last item More...
 
const_reference back () const
 the last item const More...
 
allocator_type get_allocator () const
 return allocator object More...
 
void assign (size_type n, const_reference t)
 assign n items by copying t item More...
 
template<class I >
void assign (I first, I last)
 assign range [first, last) More...
 
void assign (std::initializer_list< T > init_list)
 assigns an initializer list More...
 
void swap (concurrent_vector &vector)
 swap two instances More...
 
void clear ()
 Clear container while keeping memory allocated. More...
 
 ~concurrent_vector ()
 Clear and destroy vector. More...
 
const internal::concurrent_vector_base_v3 & internal_vector_base () const
 
template<typename I >
void copy_range (void *dst, const void *p_type_erased_iterator, size_type n)
 

Private Member Functions

void internal_free_segments (segment_t table[], segment_index_t k, segment_index_t first_block)
 Free k segments from table. More...
 
T & internal_subscript (size_type index) const
 Get reference to element at given index. More...
 
T & internal_subscript_with_exceptions (size_type index) const
 Get reference to element at given index with errors checks. More...
 
void internal_assign_n (size_type n, const_pointer p)
 assign n items by copying t More...
 
template<class I >
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.1.1p9 More...
 
template<class I >
void internal_assign_range (I first, I last, is_integer_tag< false > *)
 inline proxy assign by iterators More...
 
template<class I >
void internal_assign_iterators (I first, I last)
 assign by iterators More...
 
- Private Member Functions inherited from tbb::internal::concurrent_vector_base_v3
 concurrent_vector_base_v3 ()
 
__TBB_EXPORTED_METHOD ~concurrent_vector_base_v3 ()
 
void __TBB_EXPORTED_METHOD internal_reserve (size_type n, size_type element_size, size_type max_size)
 
size_type __TBB_EXPORTED_METHOD internal_capacity () const
 
void internal_grow (size_type start, size_type finish, size_type element_size, internal_array_op2 init, const void *src)
 
size_type __TBB_EXPORTED_METHOD internal_grow_by (size_type delta, size_type element_size, internal_array_op2 init, const void *src)
 
void *__TBB_EXPORTED_METHOD internal_push_back (size_type element_size, size_type &index)
 
segment_index_t __TBB_EXPORTED_METHOD internal_clear (internal_array_op1 destroy)
 
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_copy (const concurrent_vector_base_v3 &src, size_type element_size, internal_array_op2 copy)
 
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)
 
void __TBB_EXPORTED_METHOD internal_throw_exception (size_type) const
 Obsolete. More...
 
void __TBB_EXPORTED_METHOD internal_swap (concurrent_vector_base_v3 &v)
 
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)
 
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_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. More...
 

Static Private Member Functions

static voidinternal_allocator (internal::concurrent_vector_base_v3 &vb, size_t k)
 Allocate k items. More...
 
static void __TBB_EXPORTED_FUNC initialize_array (void *begin, const void *, size_type n)
 Construct n instances of T, starting at "begin". More...
 
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". More...
 
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". More...
 
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. More...
 
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 src array. More...
 
template<typename Iterator >
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). More...
 
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 array. More...
 
static void __TBB_EXPORTED_FUNC destroy_array (void *begin, size_type n)
 Destroy n instances of T, starting at "begin". More...
 
- Static Private Member Functions inherited from tbb::internal::concurrent_vector_base_v3
static segment_index_t segment_index_of (size_type index)
 
static segment_index_t segment_base (segment_index_t k)
 
static segment_index_t segment_base_index_of (segment_index_t &index)
 
static size_type segment_size (segment_index_t k)
 
static bool is_first_element_in_segment (size_type element_index)
 

Friends

template<typename C , typename U >
class internal::vector_iterator
 

Additional Inherited Members

- Protected Types inherited from tbb::internal::allocator_base< T, A >
typedef tbb::internal::allocator_rebind< A, T >::type allocator_type
 
- Protected Member Functions inherited from tbb::internal::allocator_base< T, A >
 allocator_base (const allocator_type &a=allocator_type())
 
- Protected Attributes inherited from tbb::internal::allocator_base< T, A >
allocator_type my_allocator
 
- Private Types inherited from tbb::internal::concurrent_vector_base_v3
enum  { default_initial_segments = 1, pointers_per_short_table = 3, pointers_per_long_table = sizeof(segment_index_t) * 8 }
 
typedef size_t segment_index_t
 
typedef size_t size_type
 
typedef void(__TBB_EXPORTED_FUNCinternal_array_op1) (void *begin, size_type n)
 An operation on an n-element array starting at begin. More...
 
typedef void(__TBB_EXPORTED_FUNCinternal_array_op2) (void *dst, const void *src, size_type n)
 An operation on n-element destination array and n-element source array. More...
 
- Private Attributes inherited from tbb::internal::concurrent_vector_base_v3
void *(* vector_allocator_ptr )(concurrent_vector_base_v3 &, size_t)
 allocator function pointer More...
 
atomic< size_typemy_first_block
 count of segments in the first block More...
 
atomic< size_typemy_early_size
 Requested size of vector. More...
 
atomic< segment_t * > my_segment
 Pointer to the segments table. More...
 
segment_t my_storage [pointers_per_short_table]
 embedded storage of segment pointers More...
 

Detailed Description

template<typename T, class A>
class tbb::concurrent_vector< T, A >

Concurrent vector container.

concurrent_vector is a container having the following main properties:

  • It provides random indexed access to its elements. The index of the first element is 0.
  • It ensures safe concurrent growing its size (different threads can safely append new elements).
  • Adding new elements does not invalidate existing iterators and does not change indices of existing items.
Compatibility
The class meets all Container Requirements and Reversible Container Requirements from C++ Standard (See ISO/IEC 14882:2003(E), clause 23.1). But it doesn't meet Sequence Requirements due to absence of insert() and erase() methods.
Exception Safety
Methods working with memory allocation and/or new elements construction can throw an exception if allocator fails to allocate memory or element's default constructor throws one. Concurrent vector's element of type T must conform to the following requirements:
  • Throwing an exception is forbidden for destructor of T.
  • Default constructor of T must not throw an exception OR its non-virtual destructor must safely work when its object memory is zero-initialized.
Otherwise, the program's behavior is undefined.
If an exception happens inside growth or assignment operation, an instance of the vector becomes invalid unless it is stated otherwise in the method documentation. Invalid state means:
  • There are no guarantees that all items were initialized by a constructor. The rest of items is zero-filled, including item where exception happens.
  • An invalid vector instance cannot be repaired; it is unable to grow anymore.
  • Size and capacity reported by the vector are incorrect, and calculated as if the failed operation were successful.
  • Attempt to access not allocated elements using operator[] or iterators results in access violation or segmentation fault exception, and in case of using at() method a C++ exception is thrown.
If a concurrent grow operation successfully completes, all the elements it has added to the vector will remain valid and accessible even if one of subsequent grow operations fails.
Fragmentation
Unlike an STL vector, a concurrent_vector does not move existing elements if it needs to allocate more memory. The container is divided into a series of contiguous arrays of elements. The first reservation, growth, or assignment operation determines the size of the first array. Using small number of elements as initial size incurs fragmentation that may increase element access time. Internal layout can be optimized by method compact() that merges several smaller arrays into one solid.
Changes since TBB 2.1
  • Fixed guarantees of concurrent_vector::size() and grow_to_at_least() methods to assure elements are allocated.
  • Methods end()/rbegin()/back() are partly thread-safe since they use size() to get the end of vector
  • Added resize() methods (not thread-safe)
  • Added cbegin/cend/crbegin/crend methods
  • Changed return type of methods grow* and push_back to iterator
Changes since TBB 2.0
  • Implemented exception-safety guarantees
  • Added template argument for allocator
  • Added allocator argument in constructors
  • Faster index calculation
  • First growth call specifies a number of segments to be merged in the first allocation.
  • Fixed memory blow up for swarm of vector's instances of small size
  • Added grow_by(size_type n, const_reference t) growth using copying constructor to init new items.
  • Added STL-like constructors.
  • Added operators ==, < and derivatives
  • Added at() method, approved for using after an exception was thrown inside the vector
  • Added get_allocator() method.
  • Added assign() methods
  • Added compact() method to defragment first segments
  • Added swap() method
  • range() defaults on grainsize = 1 supporting auto grainsize algorithms.

Definition at line 61 of file concurrent_vector.h.

Member Typedef Documentation

◆ allocator_type

template<typename T, class A>
typedef internal::allocator_base<T, A>::allocator_type tbb::concurrent_vector< T, A >::allocator_type

Definition at line 564 of file concurrent_vector.h.

◆ const_iterator

template<typename T, class A>
typedef internal::vector_iterator<concurrent_vector,const T> tbb::concurrent_vector< T, A >::const_iterator

Definition at line 574 of file concurrent_vector.h.

◆ const_pointer

template<typename T, class A>
typedef const T* tbb::concurrent_vector< T, A >::const_pointer

Definition at line 571 of file concurrent_vector.h.

◆ const_range_type

template<typename T, class A>
typedef generic_range_type<const_iterator> tbb::concurrent_vector< T, A >::const_range_type

Definition at line 590 of file concurrent_vector.h.

◆ const_reference

template<typename T, class A>
typedef const T& tbb::concurrent_vector< T, A >::const_reference

Definition at line 569 of file concurrent_vector.h.

◆ const_reverse_iterator

template<typename T, class A>
typedef std::reverse_iterator<const_iterator> tbb::concurrent_vector< T, A >::const_reverse_iterator

Definition at line 579 of file concurrent_vector.h.

◆ difference_type

template<typename T, class A>
typedef ptrdiff_t tbb::concurrent_vector< T, A >::difference_type

Definition at line 567 of file concurrent_vector.h.

◆ iterator

template<typename T, class A>
typedef internal::vector_iterator<concurrent_vector,T> tbb::concurrent_vector< T, A >::iterator

Definition at line 573 of file concurrent_vector.h.

◆ pointer

template<typename T, class A>
typedef T* tbb::concurrent_vector< T, A >::pointer

Definition at line 570 of file concurrent_vector.h.

◆ range_type

template<typename T, class A>
typedef generic_range_type<iterator> tbb::concurrent_vector< T, A >::range_type

Definition at line 589 of file concurrent_vector.h.

◆ reference

template<typename T, class A>
typedef T& tbb::concurrent_vector< T, A >::reference

Definition at line 568 of file concurrent_vector.h.

◆ reverse_iterator

template<typename T, class A>
typedef std::reverse_iterator<iterator> tbb::concurrent_vector< T, A >::reverse_iterator

Definition at line 578 of file concurrent_vector.h.

◆ size_type

Definition at line 563 of file concurrent_vector.h.

◆ value_type

template<typename T, class A>
typedef T tbb::concurrent_vector< T, A >::value_type

Definition at line 566 of file concurrent_vector.h.

Constructor & Destructor Documentation

◆ concurrent_vector() [1/9]

template<typename T, class A>
tbb::concurrent_vector< T, A >::concurrent_vector ( const allocator_type a = allocator_type())
inlineexplicit

Construct empty vector.

Definition at line 597 of file concurrent_vector.h.

598  : internal::allocator_base<T, A>(a), internal::concurrent_vector_base()
599  {
601  }
concurrent_vector_base_v3 concurrent_vector_base
static void * internal_allocator(internal::concurrent_vector_base_v3 &vb, size_t k)
Allocate k items.
void *(* vector_allocator_ptr)(concurrent_vector_base_v3 &, size_t)
allocator function pointer

◆ concurrent_vector() [2/9]

template<typename T, class A>
tbb::concurrent_vector< T, A >::concurrent_vector ( std::initializer_list< T >  init_list,
const allocator_type a = allocator_type() 
)
inline

Constructor from initializer_list.

Definition at line 607 of file concurrent_vector.h.

608  : internal::allocator_base<T, A>(a), internal::concurrent_vector_base()
609  {
611  __TBB_TRY {
612  internal_assign_iterators(init_list.begin(), init_list.end());
613  } __TBB_CATCH(...) {
614  segment_t *table = my_segment.load<relaxed>();;
616  __TBB_RETHROW();
617  }
618 
619  }
concurrent_vector_base_v3 concurrent_vector_base
value_type load() const
Definition: atomic.h:302
static void * internal_allocator(internal::concurrent_vector_base_v3 &vb, size_t k)
Allocate k items.
void internal_free_segments(segment_t table[], segment_index_t k, segment_index_t first_block)
Free k segments from table.
void *(* vector_allocator_ptr)(concurrent_vector_base_v3 &, size_t)
allocator function pointer
atomic< segment_t * > my_segment
Pointer to the segments table.
segment_index_t __TBB_EXPORTED_METHOD internal_clear(internal_array_op1 destroy)
#define __TBB_CATCH(e)
Definition: tbb_stddef.h:284
#define __TBB_TRY
Definition: tbb_stddef.h:283
No ordering.
Definition: atomic.h:47
atomic< size_type > my_first_block
count of segments in the first block
static void __TBB_EXPORTED_FUNC destroy_array(void *begin, size_type n)
Destroy n instances of T, starting at "begin".
#define __TBB_RETHROW()
Definition: tbb_stddef.h:286
void internal_assign_iterators(I first, I last)
assign by iterators

◆ concurrent_vector() [3/9]

template<typename T, class A>
tbb::concurrent_vector< T, A >::concurrent_vector ( const concurrent_vector< T, A > &  vector,
const allocator_type a = allocator_type() 
)
inline

Copying constructor.

Definition at line 623 of file concurrent_vector.h.

624  : internal::allocator_base<T, A>(a), internal::concurrent_vector_base()
625  {
627  __TBB_TRY {
628  internal_copy(vector, sizeof(T), &copy_array);
629  } __TBB_CATCH(...) {
630  segment_t *table = my_segment.load<relaxed>();
632  __TBB_RETHROW();
633  }
634  }
concurrent_vector_base_v3 concurrent_vector_base
value_type load() const
Definition: atomic.h:302
static void * internal_allocator(internal::concurrent_vector_base_v3 &vb, size_t k)
Allocate k items.
void internal_free_segments(segment_t table[], segment_index_t k, segment_index_t first_block)
Free k segments from table.
void *(* vector_allocator_ptr)(concurrent_vector_base_v3 &, size_t)
allocator function pointer
atomic< segment_t * > my_segment
Pointer to the segments table.
void __TBB_EXPORTED_METHOD internal_copy(const concurrent_vector_base_v3 &src, size_type element_size, internal_array_op2 copy)
segment_index_t __TBB_EXPORTED_METHOD internal_clear(internal_array_op1 destroy)
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".
#define __TBB_CATCH(e)
Definition: tbb_stddef.h:284
#define __TBB_TRY
Definition: tbb_stddef.h:283
No ordering.
Definition: atomic.h:47
atomic< size_type > my_first_block
count of segments in the first block
static void __TBB_EXPORTED_FUNC destroy_array(void *begin, size_type n)
Destroy n instances of T, starting at "begin".
#define __TBB_RETHROW()
Definition: tbb_stddef.h:286

◆ concurrent_vector() [4/9]

template<typename T, class A>
tbb::concurrent_vector< T, A >::concurrent_vector ( concurrent_vector< T, A > &&  source)
inline

Move constructor.

Definition at line 639 of file concurrent_vector.h.

640  : internal::allocator_base<T, A>(std::move(source)), internal::concurrent_vector_base()
641  {
644  }
concurrent_vector_base_v3 concurrent_vector_base
static void * internal_allocator(internal::concurrent_vector_base_v3 &vb, size_t k)
Allocate k items.
void *(* vector_allocator_ptr)(concurrent_vector_base_v3 &, size_t)
allocator function pointer
void __TBB_EXPORTED_METHOD internal_swap(concurrent_vector_base_v3 &v)
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:305

◆ concurrent_vector() [5/9]

template<typename T, class A>
tbb::concurrent_vector< T, A >::concurrent_vector ( concurrent_vector< T, A > &&  source,
const allocator_type a 
)
inline

Definition at line 646 of file concurrent_vector.h.

647  : internal::allocator_base<T, A>(a), internal::concurrent_vector_base()
648  {
650  //C++ standard requires instances of an allocator being compared for equality,
651  //which means that memory allocated by one instance is possible to deallocate with the other one.
652  if (a == source.my_allocator) {
654  } else {
655  __TBB_TRY {
656  internal_copy(source, sizeof(T), &move_array);
657  } __TBB_CATCH(...) {
658  segment_t *table = my_segment.load<relaxed>();
660  __TBB_RETHROW();
661  }
662  }
663  }
concurrent_vector_base_v3 concurrent_vector_base
value_type load() const
Definition: atomic.h:302
static void * internal_allocator(internal::concurrent_vector_base_v3 &vb, size_t k)
Allocate k items.
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 internal_free_segments(segment_t table[], segment_index_t k, segment_index_t first_block)
Free k segments from table.
void *(* vector_allocator_ptr)(concurrent_vector_base_v3 &, size_t)
allocator function pointer
atomic< segment_t * > my_segment
Pointer to the segments table.
void __TBB_EXPORTED_METHOD internal_swap(concurrent_vector_base_v3 &v)
void __TBB_EXPORTED_METHOD internal_copy(const concurrent_vector_base_v3 &src, size_type element_size, internal_array_op2 copy)
segment_index_t __TBB_EXPORTED_METHOD internal_clear(internal_array_op1 destroy)
#define __TBB_CATCH(e)
Definition: tbb_stddef.h:284
#define __TBB_TRY
Definition: tbb_stddef.h:283
No ordering.
Definition: atomic.h:47
atomic< size_type > my_first_block
count of segments in the first block
static void __TBB_EXPORTED_FUNC destroy_array(void *begin, size_type n)
Destroy n instances of T, starting at "begin".
#define __TBB_RETHROW()
Definition: tbb_stddef.h:286

◆ concurrent_vector() [6/9]

template<typename T, class A>
template<class M >
tbb::concurrent_vector< T, A >::concurrent_vector ( const concurrent_vector< T, M > &  vector,
const allocator_type a = allocator_type() 
)
inline

Copying constructor for vector with different allocator type.

Definition at line 669 of file concurrent_vector.h.

670  : internal::allocator_base<T, A>(a), internal::concurrent_vector_base()
671  {
673  __TBB_TRY {
674  internal_copy(vector.internal_vector_base(), sizeof(T), &copy_array);
675  } __TBB_CATCH(...) {
676  segment_t *table = my_segment.load<relaxed>();
678  __TBB_RETHROW();
679  }
680  }
concurrent_vector_base_v3 concurrent_vector_base
value_type load() const
Definition: atomic.h:302
static void * internal_allocator(internal::concurrent_vector_base_v3 &vb, size_t k)
Allocate k items.
void internal_free_segments(segment_t table[], segment_index_t k, segment_index_t first_block)
Free k segments from table.
void *(* vector_allocator_ptr)(concurrent_vector_base_v3 &, size_t)
allocator function pointer
atomic< segment_t * > my_segment
Pointer to the segments table.
void __TBB_EXPORTED_METHOD internal_copy(const concurrent_vector_base_v3 &src, size_type element_size, internal_array_op2 copy)
segment_index_t __TBB_EXPORTED_METHOD internal_clear(internal_array_op1 destroy)
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".
#define __TBB_CATCH(e)
Definition: tbb_stddef.h:284
#define __TBB_TRY
Definition: tbb_stddef.h:283
No ordering.
Definition: atomic.h:47
atomic< size_type > my_first_block
count of segments in the first block
static void __TBB_EXPORTED_FUNC destroy_array(void *begin, size_type n)
Destroy n instances of T, starting at "begin".
#define __TBB_RETHROW()
Definition: tbb_stddef.h:286

◆ concurrent_vector() [7/9]

template<typename T, class A>
tbb::concurrent_vector< T, A >::concurrent_vector ( size_type  n)
inlineexplicit

Construction with initial size specified by argument n.

Definition at line 683 of file concurrent_vector.h.

684  {
686  __TBB_TRY {
687  internal_resize( n, sizeof(T), max_size(), NULL, &destroy_array, &initialize_array );
688  } __TBB_CATCH(...) {
689  segment_t *table = my_segment.load<relaxed>();
691  __TBB_RETHROW();
692  }
693  }
static void __TBB_EXPORTED_FUNC initialize_array(void *begin, const void *, size_type n)
Construct n instances of T, starting at "begin".
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)
value_type load() const
Definition: atomic.h:302
static void * internal_allocator(internal::concurrent_vector_base_v3 &vb, size_t k)
Allocate k items.
void internal_free_segments(segment_t table[], segment_index_t k, segment_index_t first_block)
Free k segments from table.
void *(* vector_allocator_ptr)(concurrent_vector_base_v3 &, size_t)
allocator function pointer
atomic< segment_t * > my_segment
Pointer to the segments table.
size_type max_size() const
Upper bound on argument to reserve.
segment_index_t __TBB_EXPORTED_METHOD internal_clear(internal_array_op1 destroy)
#define __TBB_CATCH(e)
Definition: tbb_stddef.h:284
#define __TBB_TRY
Definition: tbb_stddef.h:283
No ordering.
Definition: atomic.h:47
atomic< size_type > my_first_block
count of segments in the first block
static void __TBB_EXPORTED_FUNC destroy_array(void *begin, size_type n)
Destroy n instances of T, starting at "begin".
#define __TBB_RETHROW()
Definition: tbb_stddef.h:286

◆ concurrent_vector() [8/9]

template<typename T, class A>
tbb::concurrent_vector< T, A >::concurrent_vector ( size_type  n,
const_reference  t,
const allocator_type a = allocator_type() 
)
inline

Construction with initial size specified by argument n, initialization by copying of t, and given allocator instance.

Definition at line 696 of file concurrent_vector.h.

697  : internal::allocator_base<T, A>(a)
698  {
700  __TBB_TRY {
701  internal_resize( n, sizeof(T), max_size(), static_cast<const void*>(&t), &destroy_array, &initialize_array_by );
702  } __TBB_CATCH(...) {
703  segment_t *table = my_segment.load<relaxed>();
705  __TBB_RETHROW();
706  }
707  }
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)
value_type load() const
Definition: atomic.h:302
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".
static void * internal_allocator(internal::concurrent_vector_base_v3 &vb, size_t k)
Allocate k items.
void internal_free_segments(segment_t table[], segment_index_t k, segment_index_t first_block)
Free k segments from table.
void *(* vector_allocator_ptr)(concurrent_vector_base_v3 &, size_t)
allocator function pointer
atomic< segment_t * > my_segment
Pointer to the segments table.
size_type max_size() const
Upper bound on argument to reserve.
segment_index_t __TBB_EXPORTED_METHOD internal_clear(internal_array_op1 destroy)
#define __TBB_CATCH(e)
Definition: tbb_stddef.h:284
#define __TBB_TRY
Definition: tbb_stddef.h:283
No ordering.
Definition: atomic.h:47
atomic< size_type > my_first_block
count of segments in the first block
static void __TBB_EXPORTED_FUNC destroy_array(void *begin, size_type n)
Destroy n instances of T, starting at "begin".
#define __TBB_RETHROW()
Definition: tbb_stddef.h:286

◆ concurrent_vector() [9/9]

template<typename T, class A>
template<class I >
tbb::concurrent_vector< T, A >::concurrent_vector ( first,
last,
const allocator_type a = allocator_type() 
)
inline

Construction with copying iteration range and given allocator instance.

Definition at line 711 of file concurrent_vector.h.

712  : internal::allocator_base<T, A>(a)
713  {
715  __TBB_TRY {
716  internal_assign_range(first, last, static_cast<is_integer_tag<std::numeric_limits<I>::is_integer> *>(0) );
717  } __TBB_CATCH(...) {
718  segment_t *table = my_segment.load<relaxed>();
720  __TBB_RETHROW();
721  }
722  }
auto last(Container &c) -> decltype(begin(c))
value_type load() const
Definition: atomic.h:302
static void * internal_allocator(internal::concurrent_vector_base_v3 &vb, size_t k)
Allocate k items.
auto first(Container &c) -> decltype(begin(c))
void internal_free_segments(segment_t table[], segment_index_t k, segment_index_t first_block)
Free k segments from table.
void *(* vector_allocator_ptr)(concurrent_vector_base_v3 &, size_t)
allocator function pointer
atomic< segment_t * > my_segment
Pointer to the segments table.
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....
segment_index_t __TBB_EXPORTED_METHOD internal_clear(internal_array_op1 destroy)
#define __TBB_CATCH(e)
Definition: tbb_stddef.h:284
#define __TBB_TRY
Definition: tbb_stddef.h:283
No ordering.
Definition: atomic.h:47
atomic< size_type > my_first_block
count of segments in the first block
static void __TBB_EXPORTED_FUNC destroy_array(void *begin, size_type n)
Destroy n instances of T, starting at "begin".
#define __TBB_RETHROW()
Definition: tbb_stddef.h:286

◆ ~concurrent_vector()

template<typename T, class A>
tbb::concurrent_vector< T, A >::~concurrent_vector ( )
inline

Clear and destroy vector.

Definition at line 1012 of file concurrent_vector.h.

1012  {
1013  segment_t *table = my_segment.load<relaxed>();
1015  // base class destructor call should be then
1016  }
value_type load() const
Definition: atomic.h:302
void internal_free_segments(segment_t table[], segment_index_t k, segment_index_t first_block)
Free k segments from table.
atomic< segment_t * > my_segment
Pointer to the segments table.
segment_index_t __TBB_EXPORTED_METHOD internal_clear(internal_array_op1 destroy)
No ordering.
Definition: atomic.h:47
atomic< size_type > my_first_block
count of segments in the first block
static void __TBB_EXPORTED_FUNC destroy_array(void *begin, size_type n)
Destroy n instances of T, starting at "begin".

Member Function Documentation

◆ assign() [1/3]

template<typename T, class A>
void tbb::concurrent_vector< T, A >::assign ( size_type  n,
const_reference  t 
)
inline

assign n items by copying t item

Definition at line 978 of file concurrent_vector.h.

978  {
979  clear();
980  internal_resize( n, sizeof(T), max_size(), static_cast<const void*>(&t), &destroy_array, &initialize_array_by );
981  }
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)
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".
void clear()
Clear container while keeping memory allocated.
size_type max_size() const
Upper bound on argument to reserve.
static void __TBB_EXPORTED_FUNC destroy_array(void *begin, size_type n)
Destroy n instances of T, starting at "begin".

◆ assign() [2/3]

template<typename T, class A>
template<class I >
void tbb::concurrent_vector< T, A >::assign ( first,
last 
)
inline

assign range [first, last)

Definition at line 985 of file concurrent_vector.h.

985  {
986  clear(); internal_assign_range( first, last, static_cast<is_integer_tag<std::numeric_limits<I>::is_integer> *>(0) );
987  }
auto last(Container &c) -> decltype(begin(c))
auto first(Container &c) -> decltype(begin(c))
void clear()
Clear container while keeping memory allocated.
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....

◆ assign() [3/3]

template<typename T, class A>
void tbb::concurrent_vector< T, A >::assign ( std::initializer_list< T >  init_list)
inline

assigns an initializer list

Definition at line 991 of file concurrent_vector.h.

991  {
992  clear(); internal_assign_iterators( init_list.begin(), init_list.end());
993  }
void clear()
Clear container while keeping memory allocated.
void internal_assign_iterators(I first, I last)
assign by iterators

◆ assign_array()

template<typename T , class A >
void tbb::concurrent_vector< T, A >::assign_array ( void dst,
const void src,
size_type  n 
)
staticprivate

Assign (using operator=) n instances of T, starting at "dst" by assigning according element of src array.

Definition at line 1319 of file concurrent_vector.h.

1319  {
1320  internal_loop_guide loop(n, dst); loop.assign(src);
1321 }

Referenced by tbb::concurrent_vector< padded_element, padded_allocator_type >::operator=().

Here is the caller graph for this function:

◆ at() [1/2]

template<typename T, class A>
reference tbb::concurrent_vector< T, A >::at ( size_type  index)
inline

Get reference to element at given index. Throws exceptions on errors.

Definition at line 866 of file concurrent_vector.h.

866  {
868  }
T & internal_subscript_with_exceptions(size_type index) const
Get reference to element at given index with errors checks.

◆ at() [2/2]

template<typename T, class A>
const_reference tbb::concurrent_vector< T, A >::at ( size_type  index) const
inline

Get const reference to element at given index. Throws exceptions on errors.

Definition at line 871 of file concurrent_vector.h.

871  {
873  }
T & internal_subscript_with_exceptions(size_type index) const
Get reference to element at given index with errors checks.

◆ back() [1/2]

template<typename T, class A>
reference tbb::concurrent_vector< T, A >::back ( )
inline

the last item

Definition at line 965 of file concurrent_vector.h.

965  {
966  __TBB_ASSERT( size()>0, NULL);
967  return internal_subscript( size()-1 );
968  }
size_type size() const
Return size of vector. It may include elements under construction.
T & internal_subscript(size_type index) const
Get reference to element at given index.
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165

◆ back() [2/2]

template<typename T, class A>
const_reference tbb::concurrent_vector< T, A >::back ( ) const
inline

the last item const

Definition at line 970 of file concurrent_vector.h.

970  {
971  __TBB_ASSERT( size()>0, NULL);
972  return internal_subscript( size()-1 );
973  }
size_type size() const
Return size of vector. It may include elements under construction.
T & internal_subscript(size_type index) const
Get reference to element at given index.
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165

◆ begin() [1/2]

template<typename T, class A>
iterator tbb::concurrent_vector< T, A >::begin ( )
inline

start iterator

Definition at line 929 of file concurrent_vector.h.

929 {return iterator(*this,0);}
internal::vector_iterator< concurrent_vector, T > iterator

Referenced by tbb::concurrent_vector< padded_element, padded_allocator_type >::crend(), tbb::concurrent_vector< padded_element, padded_allocator_type >::range(), and tbb::concurrent_vector< padded_element, padded_allocator_type >::rend().

Here is the caller graph for this function:

◆ begin() [2/2]

template<typename T, class A>
const_iterator tbb::concurrent_vector< T, A >::begin ( ) const
inline

start const iterator

Definition at line 933 of file concurrent_vector.h.

933 {return const_iterator(*this,0);}
internal::vector_iterator< concurrent_vector, const T > const_iterator

◆ capacity()

template<typename T, class A>
size_type tbb::concurrent_vector< T, A >::capacity ( ) const
inline

Maximum size to which array can grow without allocating more memory. Concurrent allocations are not included in the value.

Definition at line 898 of file concurrent_vector.h.

898 {return internal_capacity();}
size_type __TBB_EXPORTED_METHOD internal_capacity() const

◆ cbegin()

template<typename T, class A>
const_iterator tbb::concurrent_vector< T, A >::cbegin ( ) const
inline

start const iterator

Definition at line 937 of file concurrent_vector.h.

937 {return const_iterator(*this,0);}
internal::vector_iterator< concurrent_vector, const T > const_iterator

◆ cend()

template<typename T, class A>
const_iterator tbb::concurrent_vector< T, A >::cend ( ) const
inline

end const iterator

Definition at line 939 of file concurrent_vector.h.

939 {return const_iterator(*this,size());}
size_type size() const
Return size of vector. It may include elements under construction.
internal::vector_iterator< concurrent_vector, const T > const_iterator

◆ clear()

template<typename T, class A>
void tbb::concurrent_vector< T, A >::clear ( )
inline

Clear container while keeping memory allocated.

To free up the memory, use in conjunction with method compact(). Not thread safe

Definition at line 1007 of file concurrent_vector.h.

1007  {
1009  }
segment_index_t __TBB_EXPORTED_METHOD internal_clear(internal_array_op1 destroy)
static void __TBB_EXPORTED_FUNC destroy_array(void *begin, size_type n)
Destroy n instances of T, starting at "begin".

Referenced by tbb::concurrent_vector< padded_element, padded_allocator_type >::assign(), and tbb::interface6::enumerable_thread_specific< T, my_alloc, ets_no_key >::clear().

Here is the caller graph for this function:

◆ copy_array()

template<typename T , class A >
void tbb::concurrent_vector< T, A >::copy_array ( void dst,
const void src,
size_type  n 
)
staticprivate

Copy-construct n instances of T by copying single element pointed to by src, starting at "dst".

Definition at line 1289 of file concurrent_vector.h.

1289  {
1290  internal_loop_guide loop(n, dst); loop.copy(src);
1291 }

Referenced by tbb::concurrent_vector< padded_element, padded_allocator_type >::concurrent_vector(), and tbb::concurrent_vector< padded_element, padded_allocator_type >::operator=().

Here is the caller graph for this function:

◆ copy_range() [1/2]

template<typename T, class A>
template<typename Iterator >
static void __TBB_EXPORTED_FUNC tbb::concurrent_vector< T, A >::copy_range ( void dst,
const void p_type_erased_iterator,
size_type  n 
)
staticprivate

Copy-construct n instances of T, starting at "dst" by iterator range of [p_type_erased_iterator, p_type_erased_iterator+n).

◆ copy_range() [2/2]

template<typename T, class A>
template<typename I >
void tbb::concurrent_vector< T, A >::copy_range ( void dst,
const void p_type_erased_iterator,
size_type  n 
)

Definition at line 1313 of file concurrent_vector.h.

1313  {
1314  internal_loop_guide loop(n, dst);
1315  loop.iterate( *(static_cast<I*>(const_cast<void*>(p_type_erased_iterator))) );
1316 }

◆ crbegin()

template<typename T, class A>
const_reverse_iterator tbb::concurrent_vector< T, A >::crbegin ( ) const
inline

reverse start const iterator

Definition at line 949 of file concurrent_vector.h.

949 {return const_reverse_iterator(end());}
iterator end()
end iterator
std::reverse_iterator< const_iterator > const_reverse_iterator

◆ crend()

template<typename T, class A>
const_reverse_iterator tbb::concurrent_vector< T, A >::crend ( ) const
inline

reverse end const iterator

Definition at line 951 of file concurrent_vector.h.

951 {return const_reverse_iterator(begin());}
iterator begin()
start iterator
std::reverse_iterator< const_iterator > const_reverse_iterator

◆ destroy_array()

template<typename T , class A >
void tbb::concurrent_vector< T, A >::destroy_array ( void begin,
size_type  n 
)
staticprivate

Destroy n instances of T, starting at "begin".

Definition at line 1329 of file concurrent_vector.h.

1329  {
1330  T* array = static_cast<T*>(begin);
1331  for( size_type j=n; j>0; --j )
1332  array[j-1].~T(); // destructors are supposed to not throw any exceptions
1333 }
iterator begin()
start iterator
internal::concurrent_vector_base_v3::size_type size_type

Referenced by tbb::concurrent_vector< padded_element, padded_allocator_type >::assign(), tbb::concurrent_vector< padded_element, padded_allocator_type >::clear(), tbb::concurrent_vector< padded_element, padded_allocator_type >::concurrent_vector(), tbb::concurrent_vector< padded_element, padded_allocator_type >::internal_assign_n(), tbb::concurrent_vector< padded_element, padded_allocator_type >::operator=(), tbb::concurrent_vector< padded_element, padded_allocator_type >::resize(), and tbb::concurrent_vector< padded_element, padded_allocator_type >::~concurrent_vector().

Here is the caller graph for this function:

◆ emplace_back()

template<typename T, class A>
template<typename... Args>
iterator tbb::concurrent_vector< T, A >::emplace_back ( Args &&...  args)
inline

Push item, create item "in place" with provided arguments.

Returns iterator pointing to the new element.

Definition at line 845 of file concurrent_vector.h.

846  {
847  push_back_helper prolog(*this);
848  new(prolog.internal_push_back_result()) T(std::forward<Args>(args)...);
849  return prolog.return_iterator_and_dismiss();
850  }

◆ empty()

template<typename T, class A>
bool tbb::concurrent_vector< T, A >::empty ( ) const
inline

Return false if vector is not empty or has elements under construction at least.

Definition at line 895 of file concurrent_vector.h.

895 {return !my_early_size;}
atomic< size_type > my_early_size
Requested size of vector.

Referenced by tbb::interface6::enumerable_thread_specific< T, my_alloc, ets_no_key >::empty().

Here is the caller graph for this function:

◆ end() [1/2]

template<typename T, class A>
iterator tbb::concurrent_vector< T, A >::end ( )
inline

end iterator

Definition at line 931 of file concurrent_vector.h.

931 {return iterator(*this,size());}
size_type size() const
Return size of vector. It may include elements under construction.
internal::vector_iterator< concurrent_vector, T > iterator

Referenced by tbb::concurrent_vector< padded_element, padded_allocator_type >::crbegin(), tbb::concurrent_vector< padded_element, padded_allocator_type >::range(), and tbb::concurrent_vector< padded_element, padded_allocator_type >::rbegin().

Here is the caller graph for this function:

◆ end() [2/2]

template<typename T, class A>
const_iterator tbb::concurrent_vector< T, A >::end ( ) const
inline

end const iterator

Definition at line 935 of file concurrent_vector.h.

935 {return const_iterator(*this,size());}
size_type size() const
Return size of vector. It may include elements under construction.
internal::vector_iterator< concurrent_vector, const T > const_iterator

◆ front() [1/2]

template<typename T, class A>
reference tbb::concurrent_vector< T, A >::front ( )
inline

the first item

Definition at line 953 of file concurrent_vector.h.

953  {
954  __TBB_ASSERT( size()>0, NULL);
955  const segment_value_t& segment_value = my_segment[0].template load<relaxed>();
956  return (segment_value.template pointer<T>())[0];
957  }
size_type size() const
Return size of vector. It may include elements under construction.
atomic< segment_t * > my_segment
Pointer to the segments table.
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165

◆ front() [2/2]

template<typename T, class A>
const_reference tbb::concurrent_vector< T, A >::front ( ) const
inline

the first item const

Definition at line 959 of file concurrent_vector.h.

959  {
960  __TBB_ASSERT( size()>0, NULL);
961  const segment_value_t& segment_value = my_segment[0].template load<relaxed>();
962  return (segment_value.template pointer<const T>())[0];
963  }
size_type size() const
Return size of vector. It may include elements under construction.
atomic< segment_t * > my_segment
Pointer to the segments table.
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165

◆ get_allocator()

template<typename T, class A>
allocator_type tbb::concurrent_vector< T, A >::get_allocator ( ) const
inline

return allocator object

Definition at line 975 of file concurrent_vector.h.

975 { return this->my_allocator; }

◆ grow_by() [1/4]

template<typename T, class A>
iterator tbb::concurrent_vector< T, A >::grow_by ( size_type  delta)
inline

Grow by "delta" elements.

Returns iterator pointing to the first new element.

Definition at line 772 of file concurrent_vector.h.

772  {
773  return iterator(*this, delta ? internal_grow_by( delta, sizeof(T), &initialize_array, NULL ) : my_early_size.load());
774  }
static void __TBB_EXPORTED_FUNC initialize_array(void *begin, const void *, size_type n)
Construct n instances of T, starting at "begin".
value_type load() const
Definition: atomic.h:302
size_type __TBB_EXPORTED_METHOD internal_grow_by(size_type delta, size_type element_size, internal_array_op2 init, const void *src)
atomic< size_type > my_early_size
Requested size of vector.
internal::vector_iterator< concurrent_vector, T > iterator

Referenced by tbb::interface6::enumerable_thread_specific< T, my_alloc, ets_no_key >::create_local(), and tbb::concurrent_vector< padded_element, padded_allocator_type >::grow_by().

Here is the caller graph for this function:

◆ grow_by() [2/4]

template<typename T, class A>
iterator tbb::concurrent_vector< T, A >::grow_by ( size_type  delta,
const_reference  t 
)
inline

Grow by "delta" elements using copying constructor.

Returns iterator pointing to the first new element.

Definition at line 778 of file concurrent_vector.h.

778  {
779  return iterator(*this, delta ? internal_grow_by( delta, sizeof(T), &initialize_array_by, static_cast<const void*>(&t) ) : my_early_size.load());
780  }
value_type load() const
Definition: atomic.h:302
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".
size_type __TBB_EXPORTED_METHOD internal_grow_by(size_type delta, size_type element_size, internal_array_op2 init, const void *src)
atomic< size_type > my_early_size
Requested size of vector.
internal::vector_iterator< concurrent_vector, T > iterator

◆ grow_by() [3/4]

template<typename T, class A>
template<typename I >
iterator tbb::concurrent_vector< T, A >::grow_by ( first,
last 
)
inline

Returns iterator pointing to the first new element.

Definition at line 784 of file concurrent_vector.h.

784  {
785  typename std::iterator_traits<I>::difference_type delta = std::distance(first, last);
786  __TBB_ASSERT( delta >= 0, NULL);
787 
788  return iterator(*this, delta ? internal_grow_by(delta, sizeof(T), &copy_range<I>, static_cast<const void*>(&first)) : my_early_size.load());
789  }
auto last(Container &c) -> decltype(begin(c))
value_type load() const
Definition: atomic.h:302
auto first(Container &c) -> decltype(begin(c))
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
size_type __TBB_EXPORTED_METHOD internal_grow_by(size_type delta, size_type element_size, internal_array_op2 init, const void *src)
atomic< size_type > my_early_size
Requested size of vector.
internal::vector_iterator< concurrent_vector, T > iterator

◆ grow_by() [4/4]

template<typename T, class A>
iterator tbb::concurrent_vector< T, A >::grow_by ( std::initializer_list< T >  init_list)
inline

Returns iterator pointing to the first new element.

Definition at line 793 of file concurrent_vector.h.

793  {
794  return grow_by( init_list.begin(), init_list.end() );
795  }
iterator grow_by(size_type delta)
Grow by "delta" elements.

◆ grow_to_at_least() [1/2]

template<typename T, class A>
iterator tbb::concurrent_vector< T, A >::grow_to_at_least ( size_type  n)
inline

Append minimal sequence of elements such that size()>=n.

The new elements are default constructed. Blocks until all elements in range [0..n) are allocated. May return while other elements are being constructed by other threads. Returns iterator that points to beginning of appended sequence. If no elements were appended, returns iterator pointing to nth element.

Definition at line 803 of file concurrent_vector.h.

803  {
804  size_type m=0;
805  if( n ) {
806  m = internal_grow_to_at_least_with_result( n, sizeof(T), &initialize_array, NULL );
807  if( m>n ) m=n;
808  }
809  return iterator(*this, m);
810  };
static void __TBB_EXPORTED_FUNC initialize_array(void *begin, const void *, size_type n)
Construct n instances of T, starting at "begin".
internal::concurrent_vector_base_v3::size_type size_type
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)
internal::vector_iterator< concurrent_vector, T > iterator

◆ grow_to_at_least() [2/2]

template<typename T, class A>
iterator tbb::concurrent_vector< T, A >::grow_to_at_least ( size_type  n,
const_reference  t 
)
inline

Analogous to grow_to_at_least( size_type n ) with exception that the new elements are initialized by copying of t instead of default construction.

Definition at line 814 of file concurrent_vector.h.

814  {
815  size_type m=0;
816  if( n ) {
818  if( m>n ) m=n;
819  }
820  return iterator(*this, m);
821  };
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".
internal::concurrent_vector_base_v3::size_type size_type
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)
internal::vector_iterator< concurrent_vector, T > iterator

◆ initialize_array()

template<typename T , class A >
void tbb::concurrent_vector< T, A >::initialize_array ( void begin,
const void ,
size_type  n 
)
staticprivate

Construct n instances of T, starting at "begin".

Definition at line 1279 of file concurrent_vector.h.

1279  {
1280  internal_loop_guide loop(n, begin); loop.init();
1281 }
iterator begin()
start iterator

Referenced by tbb::concurrent_vector< padded_element, padded_allocator_type >::concurrent_vector(), tbb::concurrent_vector< padded_element, padded_allocator_type >::grow_by(), tbb::concurrent_vector< padded_element, padded_allocator_type >::grow_to_at_least(), tbb::concurrent_vector< padded_element, padded_allocator_type >::internal_assign_n(), and tbb::concurrent_vector< padded_element, padded_allocator_type >::resize().

Here is the caller graph for this function:

◆ initialize_array_by()

template<typename T , class A >
void tbb::concurrent_vector< T, A >::initialize_array_by ( void begin,
const void src,
size_type  n 
)
staticprivate

Copy-construct n instances of T, starting at "begin".

Definition at line 1284 of file concurrent_vector.h.

1284  {
1285  internal_loop_guide loop(n, begin); loop.init(src);
1286 }
iterator begin()
start iterator

Referenced by tbb::concurrent_vector< padded_element, padded_allocator_type >::assign(), tbb::concurrent_vector< padded_element, padded_allocator_type >::concurrent_vector(), tbb::concurrent_vector< padded_element, padded_allocator_type >::grow_by(), tbb::concurrent_vector< padded_element, padded_allocator_type >::grow_to_at_least(), tbb::concurrent_vector< padded_element, padded_allocator_type >::internal_assign_n(), and tbb::concurrent_vector< padded_element, padded_allocator_type >::resize().

Here is the caller graph for this function:

◆ internal_allocator()

template<typename T, class A>
static void* tbb::concurrent_vector< T, A >::internal_allocator ( internal::concurrent_vector_base_v3 &  vb,
size_t  k 
)
inlinestaticprivate

Allocate k items.

Definition at line 1021 of file concurrent_vector.h.

1021  {
1022  return static_cast<concurrent_vector<T, A>&>(vb).my_allocator.allocate(k);
1023  }

Referenced by tbb::concurrent_vector< padded_element, padded_allocator_type >::concurrent_vector().

Here is the caller graph for this function:

◆ internal_assign_iterators()

template<typename T , class A >
template<class I >
void tbb::concurrent_vector< T, A >::internal_assign_iterators ( first,
last 
)
private

assign by iterators

Definition at line 1258 of file concurrent_vector.h.

1258  {
1259  __TBB_ASSERT(my_early_size == 0, NULL);
1260  size_type n = std::distance(first, last);
1261  if( !n ) return;
1262  internal_reserve(n, sizeof(T), max_size());
1263  my_early_size = n;
1264  segment_index_t k = 0;
1265  //TODO: unify segment iteration code with concurrent_base_v3::helper
1267  while( sz < n ) {
1268  internal_loop_guide loop(sz, my_segment[k].template load<relaxed>().template pointer<void>());
1269  loop.iterate(first);
1270  n -= sz;
1271  if( !k ) k = my_first_block;
1272  else { ++k; sz <<= 1; }
1273  }
1274  internal_loop_guide loop(n, my_segment[k].template load<relaxed>().template pointer<void>());
1275  loop.iterate(first);
1276 }
auto last(Container &c) -> decltype(begin(c))
auto first(Container &c) -> decltype(begin(c))
atomic< segment_t * > my_segment
Pointer to the segments table.
internal::concurrent_vector_base_v3::size_type size_type
void __TBB_EXPORTED_METHOD internal_reserve(size_type n, size_type element_size, size_type max_size)
size_type max_size() const
Upper bound on argument to reserve.
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
static size_type segment_size(segment_index_t k)
atomic< size_type > my_first_block
count of segments in the first block
atomic< size_type > my_early_size
Requested size of vector.

Referenced by tbb::concurrent_vector< padded_element, padded_allocator_type >::internal_assign_range().

Here is the caller graph for this function:

◆ internal_assign_n()

template<typename T, class A>
void tbb::concurrent_vector< T, A >::internal_assign_n ( size_type  n,
const_pointer  p 
)
inlineprivate

assign n items by copying t

Definition at line 1034 of file concurrent_vector.h.

1034  {
1035  internal_resize( n, sizeof(T), max_size(), static_cast<const void*>(p), &destroy_array, p? &initialize_array_by : &initialize_array );
1036  }
static void __TBB_EXPORTED_FUNC initialize_array(void *begin, const void *, size_type n)
Construct n instances of T, starting at "begin".
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)
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".
size_type max_size() const
Upper bound on argument to reserve.
static void __TBB_EXPORTED_FUNC destroy_array(void *begin, size_type n)
Destroy n instances of T, starting at "begin".
void const char const char int ITT_FORMAT __itt_group_sync p

Referenced by tbb::concurrent_vector< padded_element, padded_allocator_type >::internal_assign_range().

Here is the caller graph for this function:

◆ internal_assign_range() [1/2]

template<typename T, class A>
template<class I >
void tbb::concurrent_vector< T, A >::internal_assign_range ( first,
last,
is_integer_tag< true > *   
)
inlineprivate

assign integer items by copying when arguments are treated as iterators. See C++ Standard 2003 23.1.1p9

Definition at line 1049 of file concurrent_vector.h.

1049  {
1050  internal_assign_n(static_cast<size_type>(first), &static_cast<T&>(last));
1051  }
auto last(Container &c) -> decltype(begin(c))
auto first(Container &c) -> decltype(begin(c))
void internal_assign_n(size_type n, const_pointer p)
assign n items by copying t

Referenced by tbb::concurrent_vector< padded_element, padded_allocator_type >::assign(), and tbb::concurrent_vector< padded_element, padded_allocator_type >::concurrent_vector().

Here is the caller graph for this function:

◆ internal_assign_range() [2/2]

template<typename T, class A>
template<class I >
void tbb::concurrent_vector< T, A >::internal_assign_range ( first,
last,
is_integer_tag< false > *   
)
inlineprivate

inline proxy assign by iterators

Definition at line 1054 of file concurrent_vector.h.

1054  {
1056  }
auto last(Container &c) -> decltype(begin(c))
auto first(Container &c) -> decltype(begin(c))
void internal_assign_iterators(I first, I last)
assign by iterators

◆ internal_free_segments()

template<typename T , class A >
void tbb::concurrent_vector< T, A >::internal_free_segments ( segment_t  table[],
segment_index_t  k,
segment_index_t  first_block 
)
private

Free k segments from table.

Definition at line 1205 of file concurrent_vector.h.

1205  {
1206  // Free the arrays
1207  while( k > first_block ) {
1208  --k;
1209  segment_value_t segment_value = table[k].load<relaxed>();
1210  table[k].store<relaxed>(segment_not_used());
1211  if( segment_value == segment_allocated() ) // check for correct segment pointer
1212  this->my_allocator.deallocate( (segment_value.pointer<T>()), segment_size(k) );
1213  }
1214  segment_value_t segment_value = table[0].load<relaxed>();
1215  if( segment_value == segment_allocated() ) {
1216  __TBB_ASSERT( first_block > 0, NULL );
1217  while(k > 0) table[--k].store<relaxed>(segment_not_used());
1218  this->my_allocator.deallocate( (segment_value.pointer<T>()), segment_size(first_block) );
1219  }
1220 }
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
static size_type segment_size(segment_index_t k)
No ordering.
Definition: atomic.h:47

Referenced by tbb::concurrent_vector< padded_element, padded_allocator_type >::concurrent_vector(), and tbb::concurrent_vector< padded_element, padded_allocator_type >::~concurrent_vector().

Here is the caller graph for this function:

◆ internal_subscript()

template<typename T , class A >
T & tbb::concurrent_vector< T, A >::internal_subscript ( size_type  index) const
private

Get reference to element at given index.

Definition at line 1223 of file concurrent_vector.h.

1223  {
1224  //TODO: unify both versions of internal_subscript
1225  __TBB_ASSERT( index < my_early_size, "index out of bounds" );
1226  size_type j = index;
1228  __TBB_ASSERT( my_segment.load<acquire>() != my_storage || k < pointers_per_short_table, "index is being allocated" );
1229  //no need in load with acquire (load<acquire>) since thread works in own space or gets
1230  //the information about added elements via some form of external synchronization
1231  //TODO: why not make a load of my_segment relaxed as well ?
1232  //TODO: add an assertion that my_segment[k] is properly aligned to please ITT
1233  segment_value_t segment_value = my_segment[k].template load<relaxed>();
1234  __TBB_ASSERT( segment_value != segment_allocation_failed(), "the instance is broken by bad allocation. Use at() instead" );
1235  __TBB_ASSERT( segment_value != segment_not_used(), "index is being allocated" );
1236  return (( segment_value.pointer<T>()))[j];
1237 }
static segment_index_t segment_base_index_of(segment_index_t &index)
atomic< segment_t * > my_segment
Pointer to the segments table.
internal::concurrent_vector_base_v3::size_type size_type
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
segment_t my_storage[pointers_per_short_table]
embedded storage of segment pointers
Number of slots for segment pointers inside the class.
Acquire.
Definition: atomic.h:43
atomic< size_type > my_early_size
Requested size of vector.

Referenced by tbb::concurrent_vector< padded_element, padded_allocator_type >::back(), and tbb::concurrent_vector< padded_element, padded_allocator_type >::operator[]().

Here is the caller graph for this function:

◆ internal_subscript_with_exceptions()

template<typename T , class A >
T & tbb::concurrent_vector< T, A >::internal_subscript_with_exceptions ( size_type  index) const
private

Get reference to element at given index with errors checks.

Definition at line 1240 of file concurrent_vector.h.

1240  {
1241  if( index >= my_early_size )
1242  internal::throw_exception(internal::eid_out_of_range); // throw std::out_of_range
1243  size_type j = index;
1245  //TODO: refactor this condition into separate helper function, e.g. fits_into_small_table
1246  if( my_segment.load<acquire>() == my_storage && k >= pointers_per_short_table )
1248  // no need in load with acquire (load<acquire>) since thread works in own space or gets
1249  //the information about added elements via some form of external synchronization
1250  //TODO: why not make a load of my_segment relaxed as well ?
1251  //TODO: add an assertion that my_segment[k] is properly aligned to please ITT
1252  segment_value_t segment_value = my_segment[k].template load<relaxed>();
1254  return (segment_value.pointer<T>())[j];
1255 }
static segment_index_t segment_base_index_of(segment_index_t &index)
atomic< segment_t * > my_segment
Pointer to the segments table.
internal::concurrent_vector_base_v3::size_type size_type
segment_t my_storage[pointers_per_short_table]
embedded storage of segment pointers
Number of slots for segment pointers inside the class.
void throw_exception(exception_id eid)
Versionless convenience wrapper for throw_exception_v4()
Acquire.
Definition: atomic.h:43
atomic< size_type > my_early_size
Requested size of vector.
friend void enforce_segment_allocated(segment_value_t const &s, internal::exception_id exception=eid_bad_last_alloc)

Referenced by tbb::concurrent_vector< padded_element, padded_allocator_type >::at().

Here is the caller graph for this function:

◆ internal_vector_base()

template<typename T, class A>
const internal::concurrent_vector_base_v3& tbb::concurrent_vector< T, A >::internal_vector_base ( ) const
inline

Definition at line 1018 of file concurrent_vector.h.

1018 { return *this; }

◆ max_size()

template<typename T, class A>
size_type tbb::concurrent_vector< T, A >::max_size ( ) const
inline

Upper bound on argument to reserve.

Definition at line 922 of file concurrent_vector.h.

922 {return (~size_type(0))/sizeof(T);}
internal::concurrent_vector_base_v3::size_type size_type

Referenced by tbb::concurrent_vector< padded_element, padded_allocator_type >::assign(), tbb::concurrent_vector< padded_element, padded_allocator_type >::concurrent_vector(), tbb::concurrent_vector< padded_element, padded_allocator_type >::internal_assign_n(), tbb::concurrent_vector< padded_element, padded_allocator_type >::reserve(), and tbb::concurrent_vector< padded_element, padded_allocator_type >::resize().

Here is the caller graph for this function:

◆ move_array()

template<typename T , class A >
void tbb::concurrent_vector< T, A >::move_array ( void dst,
const void src,
size_type  n 
)
staticprivate

Move-construct n instances of T, starting at "dst" by copying according element of src array.

Definition at line 1295 of file concurrent_vector.h.

1295  {
1296  internal_loop_guide loop(n, dst); loop.move_construct(src);
1297 }

Referenced by tbb::concurrent_vector< padded_element, padded_allocator_type >::concurrent_vector(), and tbb::concurrent_vector< padded_element, padded_allocator_type >::operator=().

Here is the caller graph for this function:

◆ move_assign_array()

template<typename T , class A >
void tbb::concurrent_vector< T, A >::move_assign_array ( void dst,
const void src,
size_type  n 
)
staticprivate

Move-assign (using operator=) n instances of T, starting at "dst" by assigning according element of src array.

Definition at line 1299 of file concurrent_vector.h.

1299  {
1300  internal_loop_guide loop(n, dst); loop.move_assign(src);
1301 }

Referenced by tbb::concurrent_vector< padded_element, padded_allocator_type >::operator=().

Here is the caller graph for this function:

◆ operator=() [1/4]

template<typename T, class A>
concurrent_vector& tbb::concurrent_vector< T, A >::operator= ( const concurrent_vector< T, A > &  vector)
inline

Assignment.

Definition at line 725 of file concurrent_vector.h.

725  {
726  if( this != &vector )
727  internal_assign(vector, sizeof(T), &destroy_array, &assign_array, &copy_array);
728  return *this;
729  }
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)
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...
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 __TBB_EXPORTED_FUNC destroy_array(void *begin, size_type n)
Destroy n instances of T, starting at "begin".

◆ operator=() [2/4]

template<typename T, class A>
concurrent_vector& tbb::concurrent_vector< T, A >::operator= ( concurrent_vector< T, A > &&  other)
inline

Move assignment.

Definition at line 734 of file concurrent_vector.h.

734  {
735  __TBB_ASSERT(this != &other, "Move assignment to itself is prohibited ");
737  if(pocma_t::value || this->my_allocator == other.my_allocator) {
738  concurrent_vector trash (std::move(*this));
739  internal_swap(other);
740  tbb::internal::allocator_move_assignment(this->my_allocator, other.my_allocator, pocma_t());
741  } else {
743  }
744  return *this;
745  }
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)
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.
concurrent_vector(const allocator_type &a=allocator_type())
Construct empty vector.
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 __TBB_EXPORTED_METHOD internal_swap(concurrent_vector_base_v3 &v)
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:305
void allocator_move_assignment(MyAlloc &my_allocator, OtherAlloc &other_allocator, traits_true_type)
static void __TBB_EXPORTED_FUNC destroy_array(void *begin, size_type n)
Destroy 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...

◆ operator=() [3/4]

template<typename T, class A>
template<class M >
concurrent_vector& tbb::concurrent_vector< T, A >::operator= ( const concurrent_vector< T, M > &  vector)
inline

Assignment for vector with different allocator type.

Definition at line 751 of file concurrent_vector.h.

751  {
752  if( static_cast<void*>( this ) != static_cast<const void*>( &vector ) )
753  internal_assign(vector.internal_vector_base(),
754  sizeof(T), &destroy_array, &assign_array, &copy_array);
755  return *this;
756  }
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)
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...
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 __TBB_EXPORTED_FUNC destroy_array(void *begin, size_type n)
Destroy n instances of T, starting at "begin".

◆ operator=() [4/4]

template<typename T, class A>
concurrent_vector& tbb::concurrent_vector< T, A >::operator= ( std::initializer_list< T >  init_list)
inline

Assignment for initializer_list.

Definition at line 760 of file concurrent_vector.h.

760  {
762  internal_assign_iterators(init_list.begin(), init_list.end());
763  return *this;
764  }
segment_index_t __TBB_EXPORTED_METHOD internal_clear(internal_array_op1 destroy)
static void __TBB_EXPORTED_FUNC destroy_array(void *begin, size_type n)
Destroy n instances of T, starting at "begin".
void internal_assign_iterators(I first, I last)
assign by iterators

◆ operator[]() [1/2]

template<typename T, class A>
reference tbb::concurrent_vector< T, A >::operator[] ( size_type  index)
inline

Get reference to element at given index.

This method is thread-safe for concurrent reads, and also while growing the vector, as long as the calling thread has checked that index < size().

Definition at line 856 of file concurrent_vector.h.

856  {
857  return internal_subscript(index);
858  }
T & internal_subscript(size_type index) const
Get reference to element at given index.

◆ operator[]() [2/2]

template<typename T, class A>
const_reference tbb::concurrent_vector< T, A >::operator[] ( size_type  index) const
inline

Get const reference to element at given index.

Definition at line 861 of file concurrent_vector.h.

861  {
862  return internal_subscript(index);
863  }
T & internal_subscript(size_type index) const
Get reference to element at given index.

◆ push_back() [1/2]

template<typename T, class A>
iterator tbb::concurrent_vector< T, A >::push_back ( const_reference  item)
inline

Push item.

Returns iterator pointing to the new element.

Definition at line 825 of file concurrent_vector.h.

826  {
827  push_back_helper prolog(*this);
828  new(prolog.internal_push_back_result()) T(item);
829  return prolog.return_iterator_and_dismiss();
830  }

◆ push_back() [2/2]

template<typename T, class A>
iterator tbb::concurrent_vector< T, A >::push_back ( T &&  item)
inline

Push item, move-aware.

Returns iterator pointing to the new element.

Definition at line 835 of file concurrent_vector.h.

836  {
837  push_back_helper prolog(*this);
838  new(prolog.internal_push_back_result()) T(std::move(item));
839  return prolog.return_iterator_and_dismiss();
840  }
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:305

◆ range() [1/2]

template<typename T, class A>
range_type tbb::concurrent_vector< T, A >::range ( size_t  grainsize = 1)
inline

Get range for iterating with parallel algorithms.

Definition at line 876 of file concurrent_vector.h.

876  {
877  return range_type( begin(), end(), grainsize );
878  }
iterator begin()
start iterator
iterator end()
end iterator
generic_range_type< iterator > range_type

◆ range() [2/2]

template<typename T, class A>
const_range_type tbb::concurrent_vector< T, A >::range ( size_t  grainsize = 1) const
inline

Get const range for iterating with parallel algorithms.

Definition at line 881 of file concurrent_vector.h.

881  {
882  return const_range_type( begin(), end(), grainsize );
883  }
generic_range_type< const_iterator > const_range_type
iterator begin()
start iterator
iterator end()
end iterator

◆ rbegin() [1/2]

template<typename T, class A>
reverse_iterator tbb::concurrent_vector< T, A >::rbegin ( )
inline

reverse start iterator

Definition at line 941 of file concurrent_vector.h.

941 {return reverse_iterator(end());}
iterator end()
end iterator
std::reverse_iterator< iterator > reverse_iterator

◆ rbegin() [2/2]

template<typename T, class A>
const_reverse_iterator tbb::concurrent_vector< T, A >::rbegin ( ) const
inline

reverse start const iterator

Definition at line 945 of file concurrent_vector.h.

945 {return const_reverse_iterator(end());}
iterator end()
end iterator
std::reverse_iterator< const_iterator > const_reverse_iterator

◆ rend() [1/2]

template<typename T, class A>
reverse_iterator tbb::concurrent_vector< T, A >::rend ( )
inline

reverse end iterator

Definition at line 943 of file concurrent_vector.h.

943 {return reverse_iterator(begin());}
iterator begin()
start iterator
std::reverse_iterator< iterator > reverse_iterator

◆ rend() [2/2]

template<typename T, class A>
const_reverse_iterator tbb::concurrent_vector< T, A >::rend ( ) const
inline

reverse end const iterator

Definition at line 947 of file concurrent_vector.h.

947 {return const_reverse_iterator(begin());}
iterator begin()
start iterator
std::reverse_iterator< const_iterator > const_reverse_iterator

◆ reserve()

template<typename T, class A>
void tbb::concurrent_vector< T, A >::reserve ( size_type  n)
inline

Allocate enough space to grow to size n without having to allocate more memory later.

Like most of the methods provided for STL compatibility, this method is not thread safe. The capacity afterwards may be bigger than the requested reservation.

Definition at line 903 of file concurrent_vector.h.

903  {
904  if( n )
905  internal_reserve(n, sizeof(T), max_size());
906  }
void __TBB_EXPORTED_METHOD internal_reserve(size_type n, size_type element_size, size_type max_size)
size_type max_size() const
Upper bound on argument to reserve.

Referenced by tbb::interface6::enumerable_thread_specific< T, my_alloc, ets_no_key >::internal_copy(), and tbb::interface6::enumerable_thread_specific< T, my_alloc, ets_no_key >::internal_move().

Here is the caller graph for this function:

◆ resize() [1/2]

template<typename T, class A>
void tbb::concurrent_vector< T, A >::resize ( size_type  n)
inline

Resize the vector. Not thread-safe.

Definition at line 909 of file concurrent_vector.h.

909  {
910  internal_resize( n, sizeof(T), max_size(), NULL, &destroy_array, &initialize_array );
911  }
static void __TBB_EXPORTED_FUNC initialize_array(void *begin, const void *, size_type n)
Construct n instances of T, starting at "begin".
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)
size_type max_size() const
Upper bound on argument to reserve.
static void __TBB_EXPORTED_FUNC destroy_array(void *begin, size_type n)
Destroy n instances of T, starting at "begin".

◆ resize() [2/2]

template<typename T, class A>
void tbb::concurrent_vector< T, A >::resize ( size_type  n,
const_reference  t 
)
inline

Resize the vector, copy t for new elements. Not thread-safe.

Definition at line 914 of file concurrent_vector.h.

914  {
915  internal_resize( n, sizeof(T), max_size(), static_cast<const void*>(&t), &destroy_array, &initialize_array_by );
916  }
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)
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".
size_type max_size() const
Upper bound on argument to reserve.
static void __TBB_EXPORTED_FUNC destroy_array(void *begin, size_type n)
Destroy n instances of T, starting at "begin".

◆ shrink_to_fit()

template<typename T , class A >
void tbb::concurrent_vector< T, A >::shrink_to_fit ( )

Optimize memory usage and fragmentation.

Definition at line 1182 of file concurrent_vector.h.

1182  {
1183  internal_segments_table old;
1184  __TBB_TRY {
1185  internal_array_op2 copy_or_move_array =
1186 #if __TBB_MOVE_IF_NOEXCEPT_PRESENT
1187  &move_array_if_noexcept
1188 #else
1189  &copy_array
1190 #endif
1191  ;
1192  if( internal_compact( sizeof(T), &old, &destroy_array, copy_or_move_array ) )
1193  internal_free_segments( old.table, pointers_per_long_table, old.first_block ); // free joined and unnecessary segments
1194  } __TBB_CATCH(...) {
1195  if( old.first_block ) // free segment allocated for compacting. Only for support of exceptions in ctor of user T[ype]
1196  internal_free_segments( old.table, 1, old.first_block );
1197  __TBB_RETHROW();
1198  }
1199 }
void internal_free_segments(segment_t table[], segment_index_t k, segment_index_t first_block)
Free k segments from table.
void *__TBB_EXPORTED_METHOD internal_compact(size_type element_size, void *table, internal_array_op1 destroy, internal_array_op2 copy)
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".
#define __TBB_CATCH(e)
Definition: tbb_stddef.h:284
#define __TBB_TRY
Definition: tbb_stddef.h:283
static void __TBB_EXPORTED_FUNC destroy_array(void *begin, size_type n)
Destroy n instances of T, starting at "begin".
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.
#define __TBB_RETHROW()
Definition: tbb_stddef.h:286

◆ size()

template<typename T, class A>
size_type tbb::concurrent_vector< T, A >::size ( ) const
inline

◆ swap()

template<typename T, class A>
void tbb::concurrent_vector< T, A >::swap ( concurrent_vector< T, A > &  vector)
inline

swap two instances

Definition at line 997 of file concurrent_vector.h.

997  {
999  if( this != &vector && (this->my_allocator == vector.my_allocator || pocs_t::value) ) {
1000  concurrent_vector_base_v3::internal_swap(static_cast<concurrent_vector_base_v3&>(vector));
1001  tbb::internal::allocator_swap(this->my_allocator, vector.my_allocator, pocs_t());
1002  }
1003  }
void allocator_swap(MyAlloc &my_allocator, OtherAlloc &other_allocator, traits_true_type)
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 __TBB_EXPORTED_METHOD internal_swap(concurrent_vector_base_v3 &v)

Friends And Related Function Documentation

◆ internal::vector_iterator

template<typename T, class A>
template<typename C , typename U >
friend class internal::vector_iterator
friend

Definition at line 557 of file concurrent_vector.h.


The documentation for this class was generated from the following file:

Copyright © 2005-2019 Intel Corporation. All Rights Reserved.

Intel, Pentium, Intel Xeon, Itanium, Intel XScale and VTune are registered trademarks or trademarks of Intel Corporation or its subsidiaries in the United States and other countries.

* Other names and brands may be claimed as the property of others.