tbb::concurrent_vector< T, A > Class Template Reference - Hhvm

Classes | Public Types | Public Member Functions | Friends | List of all members

tbb::concurrent_vector< T, A > Class Template Reference Containers

Concurrent vector container. More...

#include <concurrent_vector.h>

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

Public Types

Public Member Functions

Friends

Detailed Description

template<typename T, class A = cache_aligned_allocator<T>> 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.

CompatibilityThe 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 SafetyMethods 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.FragmentationUnlike 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)](a00060.html#aa11fc991cda82cf93789fce31b37a16c "Grow by "delta" elements using copying constructor. ") 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.