87         return *this;
97         return *this;
107         return *this;
137         return *this;
141         vector_iterator result = *this;
142         ++(*this);
158         return *this;
162         vector_iterator result = *this;
163         --(*this);
350         return *this;
355         return *this;  in noexcept()
360         return *this;
462     iterator begin() { return iterator(*this, 0); }  in begin()
463     const_iterator begin() const { return const_iterator(*this, 0); }  in begin()
464     const_iterator cbegin() const { return const_iterator(*this, 0); }  in cbegin()
466     iterator end() { return iterator(*this, size()); }  in end()
467     const_iterator end() const { return const_iterator(*this, size()); }  in end()
468     const_iterator cend() const { return const_iterator(*this, size()); }  in cend()
488         return std::min(this->my_size.load(std::memory_order_acquire), capacity());  in size()
506         this->assign_first_block_if_necessary(this->segment_index_of(n - 1) + 1);  in reserve()
541         __TBB_ASSERT(start_index <= this->embedded_table_size, "Start index out of embedded table");  in allocate_long_table()
545         for (segment_index_type i = 0; this->segment_base(i) < start_index; ++i) {  in allocate_long_table()
550         if (this->get_table() != embedded_table) {  in allocate_long_table()
555 …le = segment_table_allocator_traits::allocate(base_type::get_allocator(), this->pointers_per_long_…  in allocate_long_table()
557 …for (size_type segment_index = 0; segment_index < this->pointers_per_embedded_table; ++segment_ind…  in allocate_long_table()
561 …for (size_type segment_index = this->pointers_per_embedded_table; segment_index < this->pointers_p…  in allocate_long_table()
570         size_type first_block = this->my_first_block.load(std::memory_order_relaxed);  in create_segment()
581             size_type first_block_size = this->segment_size(first_block);  in create_segment()
586 …    if (table[0].compare_exchange_strong(disabled_segment, this->segment_allocation_failure_tag)) {  in create_segment()
587 …size_type end_segment = table == this->my_embedded_table ? this->pointers_per_embedded_table : fir…  in create_segment()
589 …                   table[i].store(this->segment_allocation_failure_tag, std::memory_order_release);  in create_segment()
596                 this->extend_table_if_necessary(table, 0, first_block_size);  in create_segment()
602 …             for (size_type i = 1; i < first_block && i < this->pointers_per_embedded_table; ++i) {  in create_segment()
603                     this->my_embedded_table[i].store(new_segment, std::memory_order_release);  in create_segment()
605             } else if (new_segment != this->segment_allocation_failure_tag) {  in create_segment()
612             size_type offset = this->segment_base(seg_index);  in create_segment()
616                 segment_type new_segment = this->segment_allocation_failure_tag;  in create_segment()
618 …new_segment = segment_element_allocator_traits::allocate(segment_allocator,this->segment_size(seg_…  in create_segment()
620                     new_segment -= this->segment_base(seg_index);  in create_segment()
633         size_type curr_vector_size = this->my_size.load(std::memory_order_relaxed);  in number_of_elements_in_segment()
634         size_type curr_segment_base = this->segment_base(seg_index);  in number_of_elements_in_segment()
637             return std::min(curr_vector_size, this->segment_size(seg_index));  in number_of_elements_in_segment()
649         if (segment_index >= this->my_first_block) {  in nullify_segment()
653                 for (size_type i = 0; i < this->my_first_block; ++i) {  in nullify_segment()
664         size_type first_block = this->my_first_block.load(std::memory_order_relaxed);  in deallocate_segment()
666 …segment_element_allocator_traits::deallocate(segment_allocator, address, this->segment_size(seg_in…  in deallocate_segment()
669 …size_type elements_to_deallocate = first_block > 0 ? this->segment_size(first_block) : this->segme…  in deallocate_segment()
695 …  zero_unconstructed_elements(this->get_segment(seg_index) + i, this->segment_size(seg_index) - i);  in copy_segment()
697 …segment_index_type last_segment = this->segment_index_of(this->my_size.load(std::memory_order_rela…  in copy_segment()
698             auto table = this->get_table();  in copy_segment()
702 …          zero_unconstructed_elements(curr_segment + this->segment_base(j), this->segment_size(j));  in copy_segment()
705             this->my_size.store(this->segment_size(seg_index) + i, std::memory_order_relaxed);  in copy_segment()
718 …  zero_unconstructed_elements(this->get_segment(seg_index) + i, this->segment_size(seg_index) - i);  in move_segment()
720 …segment_index_type last_segment = this->segment_index_of(this->my_size.load(std::memory_order_rela…  in move_segment()
721             auto table = this->get_table();  in move_segment()
725 …          zero_unconstructed_elements(curr_segment + this->segment_base(j), this->segment_size(j));  in move_segment()
728             this->my_size.store(this->segment_size(seg_index) + i, std::memory_order_relaxed);  in move_segment()
738         return const_cast<self_type*>(this)->internal_subscript(index);  in internal_subscript()
742 …    __TBB_ASSERT(index < this->my_size.load(std::memory_order_relaxed), "Invalid subscript index");  in internal_subscript()
747         return const_cast<self_type*>(this)->internal_subscript_with_exceptions(index);  in internal_subscript_with_exceptions()
751         if (index >= this->my_size.load(std::memory_order_acquire)) {  in internal_subscript_with_exceptions()
755         segment_table_type table = this->my_segment_table.load(std::memory_order_acquire);  in internal_subscript_with_exceptions()
757         size_type seg_index = this->segment_index_of(index);  in internal_subscript_with_exceptions()
762         if (table[seg_index] <= this->segment_allocation_failure_tag) {  in internal_subscript_with_exceptions()
775         size_type old_size = this->my_size++;  in internal_emplace_back()
776         this->assign_first_block_if_necessary(default_first_block_size);  in internal_emplace_back()
787         return iterator(*this, old_size, element_address);  in internal_emplace_back()
798 …              segment_index_type last_allocated_segment = this->find_last_allocated_segment(table);  in internal_loop_construct()
799                 size_type segment_size = this->segment_size(last_allocated_segment);  in internal_loop_construct()
802                     zero_unconstructed_elements(&this->internal_subscript(i), /*count =*/1);  in internal_loop_construct()
817 …              segment_index_type last_allocated_segment = this->find_last_allocated_segment(table);  in internal_loop_construct()
818                 size_type segment_size = this->segment_size(last_allocated_segment);  in internal_loop_construct()
821                     zero_unconstructed_elements(&this->internal_subscript(i), /*count =*/1);  in internal_loop_construct()
829         this->assign_first_block_if_necessary(this->segment_index_of(end_idx - 1) + 1);  in internal_grow()
830         size_type seg_index = this->segment_index_of(end_idx - 1);  in internal_grow()
831         segment_table_type table = this->get_table();  in internal_grow()
832         this->extend_table_if_necessary(table, start_idx, end_idx);  in internal_grow()
834         if (seg_index > this->my_first_block.load(std::memory_order_relaxed)) {  in internal_grow()
838                 size_type first_element = this->segment_base(seg_index);  in internal_grow()
848 …return iterator(*this, start_idx, &base_type::template internal_subscript</*allow_out_of_range_acc…  in internal_grow()
857         size_type start_idx = this->my_size.fetch_add(delta);  in internal_grow_by_delta()
865         size_type old_size = this->my_size.load(std::memory_order_relaxed);  in internal_grow_to_at_least()
866         if (new_size == size_type(0)) return iterator(*this, 0);  in internal_grow_to_at_least()
867         while (old_size < new_size && !this->my_size.compare_exchange_weak(old_size, new_size))  in internal_grow_to_at_least()
875         size_type end_segment = this->segment_index_of(new_size - 1);  in internal_grow_to_at_least()
878         if (end_segment >= this->pointers_per_embedded_table &&  in internal_grow_to_at_least()
879             this->get_table() == this->my_embedded_table)  in internal_grow_to_at_least()
881             spin_wait_while_eq(this->my_segment_table, this->my_embedded_table);  in internal_grow_to_at_least()
885             if (this->get_table()[seg_idx].load(std::memory_order_relaxed) == nullptr) {  in internal_grow_to_at_least()
887                 while (this->get_table()[seg_idx].load(std::memory_order_relaxed) == nullptr) {  in internal_grow_to_at_least()
897         return iterator(*this, size());  in internal_grow_to_at_least()
907         size_type old_size = this->my_size.load(std::memory_order_acquire);  in internal_resize()
915             size_type last_segment = this->segment_index_of(old_size - 1);  in internal_resize()
917 …  for (size_type seg_idx = this->segment_index_of(n - 1) + 1; seg_idx <= last_segment; ++seg_idx) {  in internal_resize()
918                 this->delete_segment(seg_idx);  in internal_resize()
923             size_type n_segment = this->segment_index_of(n - 1);  in internal_resize()
924 …size_type last_index_to_destroy = std::min(this->segment_base(n_segment) + this->segment_size(n_se…  in internal_resize()
929             this->my_size.store(n, std::memory_order_release);  in internal_resize()
935         for (size_type i = 0; i < this->my_size.load(std::memory_order_relaxed); ++i) {  in destroy_elements()
938         this->my_size.store(0, std::memory_order_relaxed);  in destroy_elements()
948         const size_type curr_size = this->my_size.load(std::memory_order_relaxed);  in internal_compact()
949         segment_table_type table = this->get_table();  in internal_compact()
950 …const segment_index_type k_end = this->find_last_allocated_segment(table);                   // al…  in internal_compact()
951 …const segment_index_type k_stop = curr_size ? this->segment_index_of(curr_size - 1) + 1 : 0; // nu…  in internal_compact()
952 …const segment_index_type first_block = this->my_first_block;                                 // nu…  in internal_compact()
959 …         while (k < k_stop && incompact_predicate(this->segment_size(k) * sizeof(value_type))) k++;  in internal_compact()
978             this->my_first_block.store(k, std::memory_order_relaxed);  in internal_compact()
981                 for (; index < std::min(this->segment_size(max_block), curr_size); ++index) {  in internal_compact()
982                     auto element_address = &static_cast<base_type*>(this)->operator[](index);  in internal_compact()
983                     segment_index_type seg_idx = this->segment_index_of(index);  in internal_compact()
990                     auto element_adress = &this->operator[](i);  in internal_compact()
994                     table[0].load(std::memory_order_relaxed), this->segment_size(max_block));  in internal_compact()
1003                 this->my_first_block.store(first_block, std::memory_order_relaxed);  in internal_compact()
1010             this->my_first_block.store(first_block, std::memory_order_relaxed);  in internal_compact()
1014 …stroy_segment(buffer_table[seg_idx - 1].load(std::memory_order_relaxed) + this->segment_base(seg_i…  in internal_compact()
1019             this->my_first_block.store(k, std::memory_order_relaxed);  in internal_compact()
1031                     this->delete_segment(seg_idx - 1);  in internal_compact()
1034             if (!k) this->my_first_block.store(0, std::memory_order_relaxed);  in internal_compact()