#if (_MSC_VER)

//MSVC 10 "deprecated" application of some std:: algorithms to raw pointers as not safe.

//The reason is that destination is not checked against bounds/having enough place.

#define _SCL_SECURE_NO_WARNINGS

#endif

#include "tbb/concurrent_vector.h"

#include "tbb/cache_aligned_allocator.h"

#include "tbb/tbb_exception.h"

#include "tbb_misc.h"

#include "itt_notify.h"

#include <cstring>

#include <memory> //for uninitialized_fill_n

#if defined(_MSC_VER) && defined(_Wp64)

// Workaround for overzealous compiler warnings in /Wp64 mode

#pragma warning (disable: 4267)

#endif

using namespace std;

namespace tbb {

namespace internal {

class concurrent_vector_base_v3::helper :no_assign {

//! memory page size

static const size_type page_size = 4096;

inline static bool incompact_predicate(size_type size) { // assert size != 0, see source/test/test_vector_layout.cpp

return size < page_size || ((size-1)%page_size < page_size/2 && size < page_size * 128); // for more details

}

inline static size_type find_segment_end(const concurrent_vector_base_v3 &v) {

}

// TODO: optimize accesses to my_first_block

//! assign first segment size. k - is index of last segment to be allocated, not a count of segments

inline static void assign_first_segment_if_necessary(concurrent_vector_base_v3 &v, segment_index_t k) {

}

inline static void *allocate_segment(concurrent_vector_base_v3 &v, size_type n) {

void *ptr = v.vector_allocator_ptr(v, n);

if(!ptr) throw_exception(eid_bad_alloc); // check for bad allocation, throw exception

return ptr;

}

//! Publish segment so other threads can see it.

template<typename argument_type>

inline static void publish_segment( segment_t& s, argument_type rhs ) {

}

static size_type enable_segment(concurrent_vector_base_v3 &v, size_type k, size_type element_size, bool mark_as_not_used_on_failure = false);

// TODO: rename as get_segments_table() and return segment pointer

inline static void extend_table_if_necessary(concurrent_vector_base_v3 &v, size_type k, size_type start ) {

if(k >= pointers_per_short_table && v.my_segment == v.my_storage)

extend_segment_table(v, start );

}

static void extend_segment_table(concurrent_vector_base_v3 &v, size_type start);

struct segment_not_used_predicate: no_assign {

};

inline static segment_t& acquire_segment(concurrent_vector_base_v3 &v, size_type index, size_type element_size, bool owner) {

segment_t &s = v.my_segment[index]; // TODO: pass v.my_segment as argument

if( s.load<acquire>() == segment_not_used() ) { // do not check for segment_allocation_failed state

if( owner ) {

enable_segment( v, index, element_size );

} else {

ITT_NOTIFY(sync_prepare, &s);

spin_wait_while(segment_not_used_predicate(s));

ITT_NOTIFY(sync_acquired, &s);

}

} else {

ITT_NOTIFY(sync_acquired, &s);

}

enforce_segment_allocated(s.load<relaxed>()); //it's hard to recover correctly after segment_allocation_failed state

return s;

}

///// non-static fields of helper for exception-safe iteration across segments

segment_t *table;// TODO: review all segment_index_t as just short type

size_type first_block, k, sz, start, finish, element_size;

helper(segment_t *segments, size_type fb, size_type esize, size_type index, size_type s, size_type f) throw()

: table(segments), first_block(fb), k(index), sz(0), start(s), finish(f), element_size(esize) {}

inline void first_segment() throw() {

}

inline void next_segment() throw() {

}

template<typename F>

inline size_type apply(const F &func) {

}

inline segment_value_t get_segment_value(size_type index, bool wait) {

}

~helper() {

if( sz >= finish ) return; // the work is done correctly

cleanup();

}

//! Out of line code to assists destructor in infrequent cases.

void cleanup();

/// TODO: turn into lambda functions when available

struct init_body {

};

struct safe_init_body {

};

struct destroy_body {

};

};

void concurrent_vector_base_v3::helper::extend_segment_table(concurrent_vector_base_v3 &v, concurrent_vector_base_v3::size_type start) {

if( start > segment_size(pointers_per_short_table) ) start = segment_size(pointers_per_short_table);

// If other threads are trying to set pointers in the short segment, wait for them to finish their

// assignments before we copy the short segment to the long segment. Note: grow_to_at_least depends on it

for( segment_index_t i = 0; segment_base(i) < start && v.my_segment == v.my_storage; i++ ){

if(v.my_storage[i].load<relaxed>() == segment_not_used()) {

ITT_NOTIFY(sync_prepare, &v.my_storage[i]);

atomic_backoff backoff(true);

while( v.my_segment == v.my_storage && (v.my_storage[i].load<relaxed>() == segment_not_used()) )

backoff.pause();

ITT_NOTIFY(sync_acquired, &v.my_storage[i]);

}

}

if( v.my_segment != v.my_storage ) return;

segment_t* new_segment_table = (segment_t*)NFS_Allocate( pointers_per_long_table, sizeof(segment_t), NULL );

__TBB_ASSERT(new_segment_table, "NFS_Allocate should throws exception if it cannot allocate the requested storage, and not returns zero pointer" );

std::uninitialized_fill_n(new_segment_table,size_t(pointers_per_long_table),segment_t()); //init newly allocated table

//TODO: replace with static assert

__TBB_STATIC_ASSERT(pointers_per_long_table >= pointers_per_short_table, "size of the big table should be not lesser than of the small one, as we copy values to it" );

std::copy(v.my_storage, v.my_storage+pointers_per_short_table, new_segment_table);//copy values from old table, here operator= of segment_t is used

if( v.my_segment.compare_and_swap( new_segment_table, v.my_storage ) != v.my_storage )

NFS_Free( new_segment_table );

// else TODO: add ITT_NOTIFY signals for v.my_segment?

}

concurrent_vector_base_v3::size_type concurrent_vector_base_v3::helper::enable_segment(concurrent_vector_base_v3 &v, concurrent_vector_base_v3::size_type k, concurrent_vector_base_v3::size_type element_size,

bool mark_as_not_used_on_failure ) {

struct segment_scope_guard : no_copy{

};

segment_t* s = v.my_segment; // TODO: optimize out as argument? Optimize accesses to my_first_block

__TBB_ASSERT(s[k].load<relaxed>() != segment_allocated(), "concurrent operation during growth?");

size_type size_of_enabled_segment = segment_size(k);

size_type size_to_allocate = size_of_enabled_segment;

if( !k ) {

assign_first_segment_if_necessary(v, default_initial_segments-1);

size_of_enabled_segment = 2 ;

size_to_allocate = segment_size(v.my_first_block);

} else {

spin_wait_while_eq( v.my_first_block, segment_index_t(0) );

}

if( k && (k < v.my_first_block)){ //no need to allocate anything

// s[0].array is changed only once ( 0 -> !0 ) and points to uninitialized memory

segment_value_t array0 = s[0].load<acquire>();

if(array0 == segment_not_used()){

// sync_prepare called only if there is a wait

ITT_NOTIFY(sync_prepare, &s[0]);

spin_wait_while( segment_not_used_predicate(s[0]));

array0 = s[0].load<acquire>();

}

ITT_NOTIFY(sync_acquired, &s[0]);

segment_scope_guard k_segment_guard(s[k], false);

enforce_segment_allocated(array0); // initial segment should be allocated

k_segment_guard.dismiss();

publish_segment( s[k],

static_cast<void*>(array0.pointer<char>() + segment_base(k)*element_size )

);

} else {

segment_scope_guard k_segment_guard(s[k], mark_as_not_used_on_failure);

publish_segment(s[k], allocate_segment(v, size_to_allocate));

k_segment_guard.dismiss();

}

return size_of_enabled_segment;

}

void concurrent_vector_base_v3::helper::cleanup() {

if( !sz ) { // allocation failed, restore the table

segment_index_t k_start = k, k_end = segment_index_of(finish-1);

if( segment_base( k_start ) < start )

get_segment_value(k_start++, true); // wait

if( k_start < first_block ) {

segment_value_t segment0 = get_segment_value(0, start>0); // wait if necessary

if((segment0 != segment_not_used()) && !k_start ) ++k_start;

if(segment0 != segment_allocated())

for(; k_start < first_block && k_start <= k_end; ++k_start )

publish_segment(table[k_start], segment_allocation_failed());

else for(; k_start < first_block && k_start <= k_end; ++k_start )

publish_segment(table[k_start], static_cast<void*>(

(segment0.pointer<char>()) + segment_base(k_start)*element_size) );

}

for(; k_start <= k_end; ++k_start ) // not in first block

if(table[k_start].load<acquire>() == segment_not_used())

publish_segment(table[k_start], segment_allocation_failed());

// fill allocated items

first_segment();

goto recover;

}

while( sz <= finish ) { // there is still work for at least one segment

next_segment();

recover:

segment_value_t array = table[k].load<relaxed>();

if(array == segment_allocated())

std::memset( (array.pointer<char>()) + element_size*start, 0, ((sz<finish?sz:finish) - start)*element_size );

else __TBB_ASSERT( array == segment_allocation_failed(), NULL );

}

}

concurrent_vector_base_v3::~concurrent_vector_base_v3() {

segment_t* s = my_segment;

if( s != my_storage ) {

#if TBB_USE_ASSERT

//to please assert in segment_t destructor

std::fill_n(my_storage,size_t(pointers_per_short_table),segment_t());

#endif /* TBB_USE_ASSERT */

#if TBB_USE_DEBUG

for( segment_index_t i = 0; i < pointers_per_long_table; i++)

__TBB_ASSERT( my_segment[i].load<relaxed>() != segment_allocated(), "Segment should have been freed. Please recompile with new TBB before using exceptions.");

#endif

my_segment = my_storage;

NFS_Free( s );

}

}

concurrent_vector_base_v3::size_type concurrent_vector_base_v3::internal_capacity() const {

return segment_base( helper::find_segment_end(*this) );

}

void concurrent_vector_base_v3::internal_throw_exception(size_type t) const {

}

void concurrent_vector_base_v3::internal_reserve( size_type n, size_type element_size, size_type max_size ) {

}

void concurrent_vector_base_v3::internal_copy( const concurrent_vector_base_v3& src, size_type element_size, internal_array_op2 copy ) {

}

void concurrent_vector_base_v3::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* concurrent_vector_base_v3::internal_push_back( size_type element_size, size_type& index ) {

__TBB_ASSERT( sizeof(my_early_size)==sizeof(uintptr_t), NULL );

size_type tmp = my_early_size.fetch_and_increment<acquire>();

index = tmp;

segment_index_t k_old = segment_index_of( tmp );

size_type base = segment_base(k_old);

helper::extend_table_if_necessary(*this, k_old, tmp);

segment_t& s = helper::acquire_segment(*this, k_old, element_size, base==tmp);

size_type j_begin = tmp-base;

return (void*)(s.load<relaxed>().pointer<char>() + element_size*j_begin);

}

void concurrent_vector_base_v3::internal_grow_to_at_least( size_type new_size, size_type element_size, internal_array_op2 init, const void *src ) {

internal_grow_to_at_least_with_result( new_size, element_size, init, src );

}

concurrent_vector_base_v3::size_type concurrent_vector_base_v3::internal_grow_to_at_least_with_result( size_type new_size, size_type element_size, internal_array_op2 init, const void *src ) {

}

concurrent_vector_base_v3::size_type concurrent_vector_base_v3::internal_grow_by( size_type delta, size_type element_size, internal_array_op2 init, const void *src ) {

}

void concurrent_vector_base_v3::internal_grow( const size_type start, size_type finish, size_type element_size, internal_array_op2 init, const void *src ) {

}

void concurrent_vector_base_v3::internal_resize( size_type n, size_type element_size, size_type max_size, const void *src,

}

concurrent_vector_base_v3::segment_index_t concurrent_vector_base_v3::internal_clear( internal_array_op1 destroy ) {

}

void *concurrent_vector_base_v3::internal_compact( size_type element_size, void *table, internal_array_op1 destroy, internal_array_op2 copy )

{

const size_type my_size = my_early_size;

const segment_index_t k_end = helper::find_segment_end(*this); // allocated segments

const segment_index_t k_stop = my_size? segment_index_of(my_size-1) + 1 : 0; // number of segments to store existing items: 0=>0; 1,2=>1; 3,4=>2; [5-8]=>3;..

const segment_index_t first_block = my_first_block; // number of merged segments, getting values from atomics

segment_index_t k = first_block;

if(k_stop < first_block)

k = k_stop;

else

while (k < k_stop && helper::incompact_predicate(segment_size( k ) * element_size) ) k++;

if(k_stop == k_end && k == first_block)

return NULL;

segment_t *const segment_table = my_segment;

internal_segments_table &old = *static_cast<internal_segments_table*>( table );

//this call is left here for sake of backward compatibility, and as a placeholder for table initialization

std::fill_n(old.table,sizeof(old.table)/sizeof(old.table[0]),segment_t());

old.first_block=0;

if ( k != first_block && k ) // first segment optimization

{

// exception can occur here

void *seg = helper::allocate_segment(*this, segment_size(k));

old.table[0].store<relaxed>(seg);

old.first_block = k; // fill info for freeing new segment if exception occurs

// copy items to the new segment

size_type my_segment_size = segment_size( first_block );

for (segment_index_t i = 0, j = 0; i < k && j < my_size; j = my_segment_size) {

__TBB_ASSERT( segment_table[i].load<relaxed>() == segment_allocated(), NULL);

void *s = static_cast<void*>(

static_cast<char*>(seg) + segment_base(i)*element_size );

//TODO: refactor to use std::min

if(j + my_segment_size >= my_size) my_segment_size = my_size - j;

__TBB_TRY { // exception can occur here

copy( s, segment_table[i].load<relaxed>().pointer<void>(), my_segment_size );

} __TBB_CATCH(...) { // destroy all the already copied items

}

my_segment_size = i? segment_size( ++i ) : segment_size( i = first_block );

}

// commit the changes

std::copy(segment_table,segment_table + k,old.table);

for (segment_index_t i = 0; i < k; i++) {

segment_table[i].store<relaxed>(static_cast<void*>(

static_cast<char*>(seg) + segment_base(i)*element_size ));

}

old.first_block = first_block; my_first_block = k; // now, first_block != my_first_block

// destroy original copies

my_segment_size = segment_size( first_block ); // old.first_block actually

for (segment_index_t i = 0, j = 0; i < k && j < my_size; j = my_segment_size) {

if(j + my_segment_size >= my_size) my_segment_size = my_size - j;

// destructors are supposed to not throw any exceptions

destroy( old.table[i].load<relaxed>().pointer<void>(), my_segment_size );

my_segment_size = i? segment_size( ++i ) : segment_size( i = first_block );

}

}

// free unnecessary segments allocated by reserve() call

if ( k_stop < k_end ) {

old.first_block = first_block;

std::copy(segment_table+k_stop, segment_table+k_end, old.table+k_stop );

std::fill_n(segment_table+k_stop, (k_end-k_stop), segment_t());

if( !k ) my_first_block = 0;

}

return table;

}

void concurrent_vector_base_v3::internal_swap(concurrent_vector_base_v3& v)

}

} // namespace internal

} // tbb