protected:

// Basic types declarations

typedef size_t segment_index_t;

typedef size_t size_type;

// Using enumerations due to Mac linking problems of static const variables

enum {

// Size constants

default_initial_segments = 1, // 2 initial items

//! Number of slots for segment pointers inside the class

pointers_per_short_table = 3, // to fit into 8 words of entire structure

pointers_per_long_table = sizeof(segment_index_t) * 8 // one segment per bit

};

public:

struct segment_not_used {};

struct segment_allocated {};

struct segment_allocation_failed {};

protected:

class segment_t;

class segment_value_t {

void* array;

private:

//TODO: More elegant way to grant access to selected functions _only_?

friend class segment_t;

explicit segment_value_t(void* an_array):array(an_array) {}

public:

friend bool operator==(segment_value_t const& lhs, segment_not_used ) { return lhs.array == 0;}

friend bool operator==(segment_value_t const& lhs, segment_allocated) { return lhs.array > internal::vector_allocation_error_flag;}

friend bool operator==(segment_value_t const& lhs, segment_allocation_failed) { return lhs.array == internal::vector_allocation_error_flag;}

template<typename argument_type>

friend bool operator!=(segment_value_t const& lhs, argument_type arg) { return ! (lhs == arg);}

template<typename T>

T* pointer() const { return static_cast<T*>(const_cast<void*>(array)); }

};

friend void enforce_segment_allocated(segment_value_t const& s, internal::exception_id exception = eid_bad_last_alloc){

if(s != segment_allocated()){

internal::throw_exception(exception);

}

}

// Segment pointer.

class segment_t {

atomic<void*> array;

public:

segment_t(){ store<relaxed>(segment_not_used());}

//Copy ctor and assignment operator are defined to ease using of stl algorithms.

//These algorithms usually not a synchronization point, so, semantic is

//intentionally relaxed here.

segment_t(segment_t const& rhs ){ array.store<relaxed>(rhs.array.load<relaxed>());}

void swap(segment_t & rhs ){

tbb::internal::swap<relaxed>(array, rhs.array);

}

segment_t& operator=(segment_t const& rhs ){

array.store<relaxed>(rhs.array.load<relaxed>());

return *this;

}

template<memory_semantics M>

segment_value_t load() const { return segment_value_t(array.load<M>());}

template<memory_semantics M>

void store(segment_not_used) {

array.store<M>(0);

}

template<memory_semantics M>

void store(segment_allocation_failed) {

__TBB_ASSERT(load<relaxed>() != segment_allocated(),"transition from \"allocated\" to \"allocation failed\" state looks non-logical");

array.store<M>(internal::vector_allocation_error_flag);

}

template<memory_semantics M>

void store(void* allocated_segment_pointer) __TBB_NOEXCEPT(true) {

__TBB_ASSERT(segment_value_t(allocated_segment_pointer) == segment_allocated(),

"other overloads of store should be used for marking segment as not_used or allocation_failed" );

array.store<M>(allocated_segment_pointer);

}

#if TBB_USE_ASSERT

~segment_t() {

__TBB_ASSERT(load<relaxed>() != segment_allocated(), "should have been freed by clear" );

}

#endif /* TBB_USE_ASSERT */

};

friend void swap(segment_t & , segment_t & ) __TBB_NOEXCEPT(true);

// Data fields

//! allocator function pointer

void* (*vector_allocator_ptr)(concurrent_vector_base_v3 &, size_t);

//! count of segments in the first block

atomic<size_type> my_first_block;

//! Requested size of vector

atomic<size_type> my_early_size;

//! Pointer to the segments table

atomic<segment_t*> my_segment;

//! embedded storage of segment pointers

segment_t my_storage[pointers_per_short_table];

// Methods

concurrent_vector_base_v3() {

//Here the semantic is intentionally relaxed.

//The reason this is next:

//Object that is in middle of construction (i.e. its constructor is not yet finished)

//cannot be used concurrently until the construction is finished.

//Thus to flag other threads that construction is finished, some synchronization with

//acquire-release semantic should be done by the (external) code that uses the vector.

//So, no need to do the synchronization inside the vector.

my_early_size.store<relaxed>(0);

my_first_block.store<relaxed>(0); // here is not default_initial_segments

my_segment.store<relaxed>(my_storage);

}

__TBB_EXPORTED_METHOD ~concurrent_vector_base_v3();

//these helpers methods use the fact that segments are allocated so

//that every segment size is a (increasing) power of 2.

//with one exception 0 segment has size of 2 as well segment 1;

//e.g. size of segment with index of 3 is 2^3=8;

static segment_index_t segment_index_of( size_type index ) {

return segment_index_t( __TBB_Log2( index|1 ) );

}

static segment_index_t segment_base( segment_index_t k ) {

return (segment_index_t(1)<<k & ~segment_index_t(1));

}

static inline segment_index_t segment_base_index_of( segment_index_t &index ) {

segment_index_t k = segment_index_of( index );

index -= segment_base(k);

return k;

}

static size_type segment_size( segment_index_t k ) {

return segment_index_t(1)<<k; // fake value for k==0

}

static bool is_first_element_in_segment(size_type element_index){

//check if element_index is a power of 2 that is at least 2.

//The idea is to detect if the iterator crosses a segment boundary,

//and 2 is the minimal index for which it's true

__TBB_ASSERT(element_index, "there should be no need to call "

"is_first_element_in_segment for 0th element" );

return is_power_of_two_at_least( element_index, 2 );

}

//! An operation on an n-element array starting at begin.

typedef void (__TBB_EXPORTED_FUNC *internal_array_op1)(void* begin, size_type n );

//! An operation on n-element destination array and n-element source array.

typedef void (__TBB_EXPORTED_FUNC *internal_array_op2)(void* dst, const void* src, size_type n );

//! Internal structure for compact()

struct internal_segments_table {

segment_index_t first_block;

segment_t table[pointers_per_long_table];

};

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 );

//! Obsolete

void __TBB_EXPORTED_METHOD internal_throw_exception(size_type) const;

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 );

//! Deprecated entry point for backwards compatibility to TBB 2.1.

void __TBB_EXPORTED_METHOD internal_grow_to_at_least( size_type new_size, size_type element_size, internal_array_op2 init, const void *src );

//! Private functionality

class helper;

friend class helper;

template<typename Container, typename Value>

friend class vector_iterator;

{

//! concurrent_vector over which we are iterating.

Container* my_vector;

//! Index into the vector

size_t my_index;

//! Caches my_vector-&gt;internal_subscript(my_index)

/** NULL if cached value is not available */

mutable Value* my_item;

template<typename C, typename T>

friend vector_iterator<C,T> operator+( ptrdiff_t offset, const vector_iterator<C,T>& v );

template<typename C, typename T, typename U>

friend bool operator==( const vector_iterator<C,T>& i, const vector_iterator<C,U>& j );

template<typename C, typename T, typename U>

friend bool operator<( const vector_iterator<C,T>& i, const vector_iterator<C,U>& j );

template<typename C, typename T, typename U>

friend ptrdiff_t operator-( const vector_iterator<C,T>& i, const vector_iterator<C,U>& j );

template<typename C, typename U>

friend class internal::vector_iterator;

#if !__TBB_TEMPLATE_FRIENDS_BROKEN

template<typename T, class A>

friend class tbb::concurrent_vector;

#else

#endif

vector_iterator( const Container& vector, size_t index, void *ptr = 0 ) :

my_vector(const_cast<Container*>(&vector)),

my_index(index),

my_item(static_cast<Value*>(ptr))

{}

public:

//! Default constructor

vector_iterator() : my_vector(NULL), my_index(~size_t(0)), my_item(NULL) {}

vector_iterator( const vector_iterator<Container,typename Container::value_type>& other ) :

my_vector(other.my_vector),

my_index(other.my_index),

my_item(other.my_item)

{}

vector_iterator operator+( ptrdiff_t offset ) const {

return vector_iterator( *my_vector, my_index+offset );

}

vector_iterator &operator+=( ptrdiff_t offset ) {

my_index+=offset;

my_item = NULL;

return *this;

}

vector_iterator operator-( ptrdiff_t offset ) const {

return vector_iterator( *my_vector, my_index-offset );

}

vector_iterator &operator-=( ptrdiff_t offset ) {

my_index-=offset;

my_item = NULL;

return *this;

}

Value& operator*() const {

Value* item = my_item;

if( !item ) {

item = my_item = &my_vector->internal_subscript(my_index);

}

__TBB_ASSERT( item==&my_vector->internal_subscript(my_index), "corrupt cache" );

return *item;

}

Value& operator[]( ptrdiff_t k ) const {

return my_vector->internal_subscript(my_index+k);

}

Value* operator->() const {return &operator*();}

//! Pre increment

vector_iterator& operator++() {

size_t element_index = ++my_index;

if( my_item ) {

//TODO: consider using of knowledge about "first_block optimization" here as well?

if( concurrent_vector_base::is_first_element_in_segment(element_index)) {

//if the iterator crosses a segment boundary, the pointer become invalid

//as possibly next segment is in another memory location

my_item= NULL;

} else {

++my_item;

}

}

return *this;

}

//! Pre decrement

vector_iterator& operator--() {

__TBB_ASSERT( my_index>0, "operator--() applied to iterator already at beginning of concurrent_vector" );

size_t element_index = my_index--;

if( my_item ) {

if(concurrent_vector_base::is_first_element_in_segment(element_index)) {

//if the iterator crosses a segment boundary, the pointer become invalid

//as possibly next segment is in another memory location

my_item= NULL;

} else {

--my_item;

}

}

return *this;

}

//! Post increment

vector_iterator operator++(int) {

vector_iterator result = *this;

operator++();

return result;

}

//! Post decrement

vector_iterator operator--(int) {

vector_iterator result = *this;

operator--();

return result;

}

// STL support

typedef ptrdiff_t difference_type;

typedef Value value_type;

typedef Value* pointer;

typedef Value& reference;

typedef std::random_access_iterator_tag iterator_category;

public:

typedef typename A::template

rebind<T>::other allocator_type;

allocator_type my_allocator;

allocator_base(const allocator_type &a = allocator_type() ) : my_allocator(a) {}

private internal::concurrent_vector_base {

template<typename I>

class generic_range_type: public blocked_range<I> {

public:

typedef T value_type;

typedef T& reference;

typedef const T& const_reference;

typedef I iterator;

typedef ptrdiff_t difference_type;

generic_range_type( I begin_, I end_, size_t grainsize_ = 1) : blocked_range<I>(begin_,end_,grainsize_) {}

template<typename U>

generic_range_type( const generic_range_type<U>& r) : blocked_range<I>(r.begin(),r.end(),r.grainsize()) {}

generic_range_type( generic_range_type& r, split ) : blocked_range<I>(r,split()) {}

};

template<typename C, typename U>

friend class internal::vector_iterator;

//------------------------------------------------------------------------

// STL compatible types

//------------------------------------------------------------------------

typedef internal::concurrent_vector_base_v3::size_type size_type;

typedef typename 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;

#if !defined(_MSC_VER) || _CPPLIB_VER>=300

// Assume ISO standard definition of std::reverse_iterator

typedef std::reverse_iterator<iterator> reverse_iterator;

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

#else

// Use non-standard std::reverse_iterator

typedef std::reverse_iterator<iterator,T,T&,T*> reverse_iterator;

typedef std::reverse_iterator<const_iterator,T,const T&,const T*> const_reverse_iterator;

#endif /* defined(_MSC_VER) && (_MSC_VER<1300) */

//------------------------------------------------------------------------

// Parallel algorithm support

//------------------------------------------------------------------------

typedef generic_range_type<iterator> range_type;

typedef generic_range_type<const_iterator> const_range_type;

//------------------------------------------------------------------------

// STL compatible constructors & destructors

//------------------------------------------------------------------------

//! Construct empty vector.

explicit concurrent_vector(const allocator_type &a = allocator_type())

: internal::allocator_base<T, A>(a), internal::concurrent_vector_base()

{

vector_allocator_ptr = &internal_allocator;

}

//Constructors are not required to have synchronization

//(for more details see comment in the concurrent_vector_base constructor).

#if __TBB_INITIALIZER_LISTS_PRESENT

//! Constructor from initializer_list

concurrent_vector(std::initializer_list<T> init_list, const allocator_type &a = allocator_type())

: internal::allocator_base<T, A>(a), internal::concurrent_vector_base()

{

vector_allocator_ptr = &internal_allocator;

__TBB_TRY {

internal_assign_iterators(init_list.begin(), init_list.end());

} __TBB_CATCH(...) {

segment_t *table = my_segment.load<relaxed>();;

internal_free_segments( table, internal_clear(&destroy_array), my_first_block.load<relaxed>());

__TBB_RETHROW();

}

}

#endif //# __TBB_INITIALIZER_LISTS_PRESENT

//! Copying constructor

concurrent_vector( const concurrent_vector& vector, const allocator_type& a = allocator_type() )

: internal::allocator_base<T, A>(a), internal::concurrent_vector_base()

{

vector_allocator_ptr = &internal_allocator;

__TBB_TRY {

internal_copy(vector, sizeof(T), &copy_array);

} __TBB_CATCH(...) {

segment_t *table = my_segment.load<relaxed>();

internal_free_segments( table, internal_clear(&destroy_array), my_first_block.load<relaxed>());

__TBB_RETHROW();

}

: internal::allocator_base<T, A>(std::move(source)), internal::concurrent_vector_base()

{

vector_allocator_ptr = &internal_allocator;

concurrent_vector_base_v3::internal_swap(source);

: internal::allocator_base<T, A>(a), internal::concurrent_vector_base()

{

vector_allocator_ptr = &internal_allocator;

//C++ standard requires instances of an allocator being compared for equality,

//which means that memory allocated by one instance is possible to deallocate with the other one.

if (a == source.my_allocator) {

concurrent_vector_base_v3::internal_swap(source);

} else {

__TBB_TRY {

internal_copy(source, sizeof(T), &move_array);

} __TBB_CATCH(...) {

segment_t *table = my_segment.load<relaxed>();

internal_free_segments( table, internal_clear(&destroy_array), my_first_block.load<relaxed>());

__TBB_RETHROW();

}

: internal::allocator_base<T, A>(a), internal::concurrent_vector_base()

{

vector_allocator_ptr = &internal_allocator;

__TBB_TRY {

internal_copy(vector.internal_vector_base(), sizeof(T), &copy_array);

segment_t *table = my_segment.load<relaxed>();

internal_free_segments( table, internal_clear(&destroy_array), my_first_block.load<relaxed>() );

__TBB_RETHROW();

{

vector_allocator_ptr = &internal_allocator;

__TBB_TRY {

internal_resize( n, sizeof(T), max_size(), NULL, &destroy_array, &initialize_array );

segment_t *table = my_segment.load<relaxed>();

internal_free_segments( table, internal_clear(&destroy_array), my_first_block.load<relaxed>() );

__TBB_RETHROW();

: internal::allocator_base<T, A>(a)

{

vector_allocator_ptr = &internal_allocator;

__TBB_TRY {

internal_resize( n, sizeof(T), max_size(), static_cast<const void*>(&t), &destroy_array, &initialize_array_by );

segment_t *table = my_segment.load<relaxed>();

internal_free_segments( table, internal_clear(&destroy_array), my_first_block.load<relaxed>() );

__TBB_RETHROW();

: internal::allocator_base<T, A>(a)

{

vector_allocator_ptr = &internal_allocator;

__TBB_TRY {

internal_assign_range(first, last, static_cast<is_integer_tag<std::numeric_limits<I>::is_integer> *>(0) );

segment_t *table = my_segment.load<relaxed>();

internal_free_segments( table, internal_clear(&destroy_array), my_first_block.load<relaxed>() );

__TBB_RETHROW();

typename std::iterator_traits<I>::difference_type delta = std::distance(first, last);

__TBB_ASSERT( delta >= 0, NULL);

return iterator(*this, delta ? internal_grow_by(delta, sizeof(T), &copy_range<I>, static_cast<const void*>(&first)) : my_early_size.load());

size_type m=0;

if( n ) {

m = internal_grow_to_at_least_with_result( n, sizeof(T), &initialize_array, NULL );

if( m>n ) m=n;

}

return iterator(*this, m);

size_type m=0;

if( n ) {

m = internal_grow_to_at_least_with_result( n, sizeof(T), &initialize_array_by, &t);

if( m>n ) m=n;

}

return iterator(*this, m);

{

push_back_helper prolog(*this);

new(prolog.internal_push_back_result()) T(item);

return prolog.return_iterator_and_dismiss();

{

push_back_helper prolog(*this);

new(prolog.internal_push_back_result()) T(std::move(item));

return prolog.return_iterator_and_dismiss();

{

push_back_helper prolog(*this);

new(prolog.internal_push_back_result()) T(std::forward<Args>(args)...);

return prolog.return_iterator_and_dismiss();

__TBB_ASSERT( size()>0, NULL);

const segment_value_t& segment_value = my_segment[0].template load<relaxed>();

return (segment_value.template pointer<T>())[0];

__TBB_ASSERT( size()>0, NULL);

const segment_value_t& segment_value = my_segment[0].template load<relaxed>();

return (segment_value.template pointer<const T>())[0];