internal::item_buffer< T, A > Class Template Reference

#include <_flow_graph_item_buffer_impl.h>

Inheritance diagram for internal::item_buffer< T, A >:

Collaboration diagram for internal::item_buffer< T, A >:

Public Types
enum	buffer_item_state { no_item =0, has_item =1, reserved_item =2 }
typedef T	item_type

Public Member Functions
	item_buffer ()
	Constructor. More...
	~item_buffer ()
void	reset ()

Protected Types
typedef size_t	size_type
typedef aligned_pair< item_type, buffer_item_state >::type	buffer_item_type
typedef tbb::internal::allocator_rebind< A, buffer_item_type >::type	allocator_type

Protected Member Functions
bool	buffer_empty () const
buffer_item_type &	item (size_type i)
const buffer_item_type &	item (size_type i) const
bool	my_item_valid (size_type i) const
bool	my_item_reserved (size_type i) const
const item_type &	get_my_item (size_t i) const
void	set_my_item (size_t i, const item_type &o)
void	fetch_item (size_t i, item_type &o)
void	move_item (size_t to, size_t from)
bool	place_item (size_t here, const item_type &me)
void	swap_items (size_t i, size_t j)
void	destroy_item (size_type i)
const item_type &	front () const
const item_type &	back () const
void	reserve_item (size_type i)
void	release_item (size_type i)
void	destroy_front ()
void	destroy_back ()
size_type	size (size_t new_tail=0)
size_type	capacity ()
bool	buffer_full ()
void	grow_my_array (size_t minimum_size)
	Grows the internal array. More...
bool	push_back (item_type &v)
bool	pop_back (item_type &v)
bool	pop_front (item_type &v)
void	clean_up_buffer (bool reset_pointers)

Protected Attributes
buffer_item_type *	my_array
size_type	my_array_size
size_type	my_head
size_type	my_tail

Static Protected Attributes
static const size_type	initial_buffer_size = 4

Detailed Description

template<typename T, typename A = cache_aligned_allocator<T>>
class internal::item_buffer< T, A >

Definition at line 40 of file _flow_graph_item_buffer_impl.h.

Member Typedef Documentation

allocator_type

template<typename T, typename A = cache_aligned_allocator<T>>

typedef tbb::internal::allocator_rebind<A, buffer_item_type>::type internal::item_buffer< T, A >::allocator_type

protected

Definition at line 47 of file _flow_graph_item_buffer_impl.h.

buffer_item_type

template<typename T, typename A = cache_aligned_allocator<T>>

typedef aligned_pair<item_type, buffer_item_state>::type internal::item_buffer< T, A >::buffer_item_type

protected

Definition at line 46 of file _flow_graph_item_buffer_impl.h.

item_type

template<typename T, typename A = cache_aligned_allocator<T>>

typedef T internal::item_buffer< T, A >::item_type

Definition at line 42 of file _flow_graph_item_buffer_impl.h.

size_type

template<typename T, typename A = cache_aligned_allocator<T>>

typedef size_t internal::item_buffer< T, A >::size_type

protected

Definition at line 45 of file _flow_graph_item_buffer_impl.h.

Member Enumeration Documentation

buffer_item_state

template<typename T, typename A = cache_aligned_allocator<T>>

enum internal::item_buffer::buffer_item_state

Enumerator
no_item
has_item
reserved_item

Definition at line 43 of file _flow_graph_item_buffer_impl.h.

{ no_item=0, has_item=1, reserved_item=2 };

Constructor & Destructor Documentation

item_buffer()

template<typename T, typename A = cache_aligned_allocator<T>>

internal::item_buffer< T, A >::item_buffer ( )

inline

Constructor.

Definition at line 230 of file _flow_graph_item_buffer_impl.h.

                       : my_array(NULL), my_array_size(0),
            my_head(0), my_tail(0) {
            grow_my_array(initial_buffer_size);
        }

~item_buffer()

template<typename T, typename A = cache_aligned_allocator<T>>

internal::item_buffer< T, A >::~item_buffer ( )

inline

Definition at line 235 of file _flow_graph_item_buffer_impl.h.

                       {
            clean_up_buffer(/*reset_pointers*/true);
        }

Member Function Documentation

back()

template<typename T, typename A = cache_aligned_allocator<T>>

const item_type& internal::item_buffer< T, A >::back ( ) const

inlineprotected

Definition at line 136 of file _flow_graph_item_buffer_impl.h.

        {
            __TBB_ASSERT(my_item_valid(my_tail - 1), "attempt to fetch head non-item");
            return get_my_item(my_tail - 1);
        }

Referenced by internal::item_buffer< OutputTuple >::pop_back().

Here is the caller graph for this function:

buffer_empty()

template<typename T, typename A = cache_aligned_allocator<T>>

bool internal::item_buffer< T, A >::buffer_empty ( ) const

inlineprotected

Definition at line 54 of file _flow_graph_item_buffer_impl.h.

{ return my_head == my_tail; }

Referenced by internal::function_input_queue< T, A >::empty().

Here is the caller graph for this function:

buffer_full()

template<typename T, typename A = cache_aligned_allocator<T>>

bool internal::item_buffer< T, A >::buffer_full ( )

inlineprotected

Definition at line 155 of file _flow_graph_item_buffer_impl.h.

{ return size() >= capacity(); }

Referenced by internal::item_buffer< OutputTuple >::push_back().

Here is the caller graph for this function:

capacity()

template<typename T, typename A = cache_aligned_allocator<T>>

size_type internal::item_buffer< T, A >::capacity ( )

inlineprotected

Definition at line 152 of file _flow_graph_item_buffer_impl.h.

{ return my_array_size; }

Referenced by internal::item_buffer< OutputTuple >::buffer_full(), and internal::item_buffer< OutputTuple >::grow_my_array().

Here is the caller graph for this function:

clean_up_buffer()

template<typename T, typename A = cache_aligned_allocator<T>>

void internal::item_buffer< T, A >::clean_up_buffer ( bool  reset_pointers )

inlineprotected

Definition at line 214 of file _flow_graph_item_buffer_impl.h.

                                                  {
            if (my_array) {
                for( size_type i=my_head; i<my_tail; ++i ) {
                    if(my_item_valid(i))
                        destroy_item(i);
                }
                allocator_type().deallocate(my_array,my_array_size);
            }
            my_array = NULL;
            if(reset_pointers) {
                my_head = my_tail = my_array_size = 0;
            }
        }

Referenced by internal::item_buffer< OutputTuple >::grow_my_array(), internal::item_buffer< OutputTuple >::reset(), and internal::item_buffer< OutputTuple >::~item_buffer().

Here is the caller graph for this function:

destroy_back()

template<typename T, typename A = cache_aligned_allocator<T>>

void internal::item_buffer< T, A >::destroy_back ( )

inlineprotected

Definition at line 147 of file _flow_graph_item_buffer_impl.h.

{ destroy_item(my_tail-1); --my_tail; }

Referenced by internal::item_buffer< OutputTuple >::pop_back().

Here is the caller graph for this function:

destroy_front()

template<typename T, typename A = cache_aligned_allocator<T>>

void internal::item_buffer< T, A >::destroy_front ( )

inlineprotected

Definition at line 146 of file _flow_graph_item_buffer_impl.h.

{ destroy_item(my_head); ++my_head; }

Referenced by internal::reservable_item_buffer< T, A >::consume_front(), internal::function_input_queue< T, A >::pop(), and internal::item_buffer< OutputTuple >::pop_front().

Here is the caller graph for this function:

destroy_item()

template<typename T, typename A = cache_aligned_allocator<T>>

void internal::item_buffer< T, A >::destroy_item ( size_type  i )

inlineprotected

Definition at line 122 of file _flow_graph_item_buffer_impl.h.

                                       {
            __TBB_ASSERT(my_item_valid(i), "destruction of invalid item");
            (tbb::internal::punned_cast<item_type *>(&(item(i).first)))->~item_type();
            item(i).second = no_item;
        }

Referenced by internal::item_buffer< OutputTuple >::clean_up_buffer(), internal::item_buffer< OutputTuple >::destroy_back(), internal::item_buffer< OutputTuple >::destroy_front(), internal::item_buffer< OutputTuple >::fetch_item(), internal::item_buffer< OutputTuple >::move_item(), and internal::item_buffer< OutputTuple >::set_my_item().

Here is the caller graph for this function:

fetch_item()

template<typename T, typename A = cache_aligned_allocator<T>>

void internal::item_buffer< T, A >::fetch_item ( size_t  i, item_type &  o  )

inlineprotected

Definition at line 88 of file _flow_graph_item_buffer_impl.h.

                                                {
            __TBB_ASSERT(my_item_valid(i), "Trying to fetch an empty slot");
            o = get_my_item(i);  // could have std::move assign semantics
            destroy_item(i);
        }

front()

template<typename T, typename A = cache_aligned_allocator<T>>

const item_type& internal::item_buffer< T, A >::front ( ) const

inlineprotected

Definition at line 129 of file _flow_graph_item_buffer_impl.h.

        {
            __TBB_ASSERT(my_item_valid(my_head), "attempt to fetch head non-item");
            return get_my_item(my_head);
        }

Referenced by internal::function_input_queue< T, A >::front(), internal::item_buffer< OutputTuple >::pop_front(), and internal::reservable_item_buffer< T, A >::reserve_front().

Here is the caller graph for this function:

get_my_item()

template<typename T, typename A = cache_aligned_allocator<T>>

const item_type& internal::item_buffer< T, A >::get_my_item ( size_t  i ) const

inlineprotected

Definition at line 72 of file _flow_graph_item_buffer_impl.h.

                                                     {
            __TBB_ASSERT(my_item_valid(i),"attempt to get invalid item");
            item_type *itm = (tbb::internal::punned_cast<item_type *>(&(item(i).first)));
            return *(const item_type *)itm;
        }

Referenced by internal::item_buffer< OutputTuple >::back(), internal::item_buffer< OutputTuple >::fetch_item(), internal::item_buffer< OutputTuple >::front(), internal::item_buffer< OutputTuple >::grow_my_array(), internal::item_buffer< OutputTuple >::move_item(), and internal::item_buffer< OutputTuple >::swap_items().

Here is the caller graph for this function:

grow_my_array()

template<typename T, typename A = cache_aligned_allocator<T>>

void internal::item_buffer< T, A >::grow_my_array ( size_t  minimum_size )

inlineprotected

Grows the internal array.

Definition at line 158 of file _flow_graph_item_buffer_impl.h.

                                                  {
            // test that we haven't made the structure inconsistent.
            __TBB_ASSERT(capacity() >= my_tail - my_head, "total items exceed capacity");
            size_type new_size = my_array_size ? 2*my_array_size : initial_buffer_size;
            while( new_size<minimum_size )
                new_size*=2;

            buffer_item_type* new_array = allocator_type().allocate(new_size);

            // initialize validity to "no"
            for( size_type i=0; i<new_size; ++i ) { new_array[i].second = no_item; }

            for( size_type i=my_head; i<my_tail; ++i) {
                if(my_item_valid(i)) {  // sequencer_node may have empty slots
                    // placement-new copy-construct; could be std::move
                    char *new_space = (char *)&(new_array[i&(new_size-1)].first);
                    (void)new(new_space) item_type(get_my_item(i));
                    new_array[i&(new_size-1)].second = item(i).second;
                }
            }

            clean_up_buffer(/*reset_pointers*/false);

            my_array = new_array;
            my_array_size = new_size;
        }

Referenced by internal::item_buffer< OutputTuple >::item_buffer(), internal::item_buffer< OutputTuple >::push_back(), and internal::item_buffer< OutputTuple >::reset().

Here is the caller graph for this function:

item() [1/2]

template<typename T, typename A = cache_aligned_allocator<T>>

buffer_item_type& internal::item_buffer< T, A >::item ( size_type  i )

inlineprotected

Definition at line 56 of file _flow_graph_item_buffer_impl.h.

                                            {
            __TBB_ASSERT(!(size_type(&(my_array[i&(my_array_size-1)].second))%alignment_of<buffer_item_state>::value),NULL);
            __TBB_ASSERT(!(size_type(&(my_array[i&(my_array_size-1)].first))%alignment_of<item_type>::value), NULL);
            return my_array[i & (my_array_size - 1) ];
        }

Referenced by internal::item_buffer< OutputTuple >::destroy_item(), internal::item_buffer< OutputTuple >::get_my_item(), internal::item_buffer< OutputTuple >::grow_my_array(), internal::item_buffer< OutputTuple >::my_item_reserved(), internal::item_buffer< OutputTuple >::my_item_valid(), internal::item_buffer< OutputTuple >::release_item(), internal::item_buffer< OutputTuple >::reserve_item(), and internal::item_buffer< OutputTuple >::set_my_item().

Here is the caller graph for this function:

item() [2/2]

template<typename T, typename A = cache_aligned_allocator<T>>

const buffer_item_type& internal::item_buffer< T, A >::item ( size_type  i ) const

inlineprotected

Definition at line 62 of file _flow_graph_item_buffer_impl.h.

                                                        {
            __TBB_ASSERT(!(size_type(&(my_array[i&(my_array_size-1)].second))%alignment_of<buffer_item_state>::value), NULL);
            __TBB_ASSERT(!(size_type(&(my_array[i&(my_array_size-1)].first))%alignment_of<item_type>::value), NULL);
            return my_array[i & (my_array_size-1)];
        }

move_item()

template<typename T, typename A = cache_aligned_allocator<T>>

void internal::item_buffer< T, A >::move_item ( size_t  to, size_t  from  )

inlineprotected

Definition at line 97 of file _flow_graph_item_buffer_impl.h.

                                               {
            __TBB_ASSERT(!my_item_valid(to), "Trying to move to a non-empty slot");
            __TBB_ASSERT(my_item_valid(from), "Trying to move from an empty slot");
            set_my_item(to, get_my_item(from));   // could have std::move semantics
            destroy_item(from);

        }

my_item_reserved()

template<typename T, typename A = cache_aligned_allocator<T>>

bool internal::item_buffer< T, A >::my_item_reserved ( size_type  i ) const

inlineprotected

Definition at line 69 of file _flow_graph_item_buffer_impl.h.

{ return item(i).second == reserved_item; }

Referenced by internal::item_buffer< OutputTuple >::release_item(), and internal::item_buffer< OutputTuple >::reserve_item().

Here is the caller graph for this function:

my_item_valid()

template<typename T, typename A = cache_aligned_allocator<T>>

bool internal::item_buffer< T, A >::my_item_valid ( size_type  i ) const

inlineprotected

Definition at line 68 of file _flow_graph_item_buffer_impl.h.

{ return (i < my_tail) && (i >= my_head) && (item(i).second != no_item); }

Referenced by internal::item_buffer< OutputTuple >::back(), internal::item_buffer< OutputTuple >::clean_up_buffer(), internal::item_buffer< OutputTuple >::destroy_item(), internal::item_buffer< OutputTuple >::fetch_item(), internal::item_buffer< OutputTuple >::front(), internal::item_buffer< OutputTuple >::get_my_item(), internal::item_buffer< OutputTuple >::grow_my_array(), internal::item_buffer< OutputTuple >::move_item(), internal::item_buffer< OutputTuple >::place_item(), internal::item_buffer< OutputTuple >::pop_back(), internal::item_buffer< OutputTuple >::pop_front(), internal::reservable_item_buffer< T, A >::reserve_front(), internal::item_buffer< OutputTuple >::reserve_item(), and internal::item_buffer< OutputTuple >::swap_items().

Here is the caller graph for this function:

place_item()

template<typename T, typename A = cache_aligned_allocator<T>>

bool internal::item_buffer< T, A >::place_item ( size_t  here, const item_type &  me  )

inlineprotected

Definition at line 106 of file _flow_graph_item_buffer_impl.h.

                                                          {
#if !TBB_DEPRECATED_SEQUENCER_DUPLICATES
            if(my_item_valid(here)) return false;
#endif
            set_my_item(here, me);
            return true;
        }

pop_back()

template<typename T, typename A = cache_aligned_allocator<T>>

bool internal::item_buffer< T, A >::pop_back ( item_type &  v )

inlineprotected

Definition at line 194 of file _flow_graph_item_buffer_impl.h.

                                    {
            if (!my_item_valid(my_tail-1)) {
                return false;
            }
            v = this->back();
            destroy_back();
            return true;
        }

pop_front()

template<typename T, typename A = cache_aligned_allocator<T>>

bool internal::item_buffer< T, A >::pop_front ( item_type &  v )

inlineprotected

Definition at line 203 of file _flow_graph_item_buffer_impl.h.

                                     {
            if(!my_item_valid(my_head)) {
                return false;
            }
            v = this->front();
            destroy_front();
            return true;
        }

Referenced by internal::function_input_queue< T, A >::pop().

Here is the caller graph for this function:

push_back()

template<typename T, typename A = cache_aligned_allocator<T>>

bool internal::item_buffer< T, A >::push_back ( item_type &  v )

inlineprotected

Definition at line 185 of file _flow_graph_item_buffer_impl.h.

                                     {
            if(buffer_full()) {
                grow_my_array(size() + 1);
            }
            set_my_item(my_tail, v);
            ++my_tail;
            return true;
        }

Referenced by internal::function_input_queue< T, A >::push().

Here is the caller graph for this function:

release_item()

template<typename T, typename A = cache_aligned_allocator<T>>

void internal::item_buffer< T, A >::release_item ( size_type  i )

inlineprotected

Definition at line 144 of file _flow_graph_item_buffer_impl.h.

{ __TBB_ASSERT(my_item_reserved(i), "item is not reserved"); item(i).second = has_item; }

Referenced by internal::reservable_item_buffer< T, A >::release_front().

Here is the caller graph for this function:

reserve_item()

template<typename T, typename A = cache_aligned_allocator<T>>

void internal::item_buffer< T, A >::reserve_item ( size_type  i )

inlineprotected

Definition at line 143 of file _flow_graph_item_buffer_impl.h.

{ __TBB_ASSERT(my_item_valid(i) && !my_item_reserved(i), "item cannot be reserved"); item(i).second = reserved_item; }

Referenced by internal::reservable_item_buffer< T, A >::reserve_front().

Here is the caller graph for this function:

reset()

template<typename T, typename A = cache_aligned_allocator<T>>

void internal::item_buffer< T, A >::reset ( )

inline

Definition at line 239 of file _flow_graph_item_buffer_impl.h.

{ clean_up_buffer(/*reset_pointers*/true); grow_my_array(initial_buffer_size); }

Referenced by internal::reservable_item_buffer< T, A >::reset(), internal::function_input_base< Input, Policy, A, multifunction_input< Input, OutputPortSet, Policy, A > >::reset_function_input_base(), and internal::queueing_port< T >::reset_receiver().

Here is the caller graph for this function:

set_my_item()

template<typename T, typename A = cache_aligned_allocator<T>>

void internal::item_buffer< T, A >::set_my_item ( size_t  i, const item_type &  o  )

inlineprotected

Definition at line 79 of file _flow_graph_item_buffer_impl.h.

                                                       {
            if(item(i).second != no_item) {
                destroy_item(i);
            }
            new(&(item(i).first)) item_type(o);
            item(i).second = has_item;
        }

Referenced by internal::item_buffer< OutputTuple >::move_item(), internal::item_buffer< OutputTuple >::place_item(), internal::item_buffer< OutputTuple >::push_back(), and internal::item_buffer< OutputTuple >::swap_items().

Here is the caller graph for this function:

size()

template<typename T, typename A = cache_aligned_allocator<T>>

size_type internal::item_buffer< T, A >::size ( size_t  new_tail = 0 )

inlineprotected

Definition at line 151 of file _flow_graph_item_buffer_impl.h.

{ return (new_tail ? new_tail : my_tail) - my_head; }

Referenced by internal::item_buffer< OutputTuple >::buffer_full(), and internal::item_buffer< OutputTuple >::push_back().

Here is the caller graph for this function:

swap_items()

template<typename T, typename A = cache_aligned_allocator<T>>

void internal::item_buffer< T, A >::swap_items ( size_t  i, size_t  j  )

inlineprotected

Definition at line 115 of file _flow_graph_item_buffer_impl.h.

                                            {
            __TBB_ASSERT(my_item_valid(i) && my_item_valid(j), "attempt to swap invalid item(s)");
            item_type temp = get_my_item(i);
            set_my_item(i, get_my_item(j));
            set_my_item(j, temp);
        }

Member Data Documentation

initial_buffer_size

template<typename T, typename A = cache_aligned_allocator<T>>

const size_type internal::item_buffer< T, A >::initial_buffer_size = 4

staticprotected

Definition at line 50 of file _flow_graph_item_buffer_impl.h.

Referenced by internal::item_buffer< OutputTuple >::grow_my_array(), internal::item_buffer< OutputTuple >::item_buffer(), and internal::item_buffer< OutputTuple >::reset().

my_array

template<typename T, typename A = cache_aligned_allocator<T>>

buffer_item_type* internal::item_buffer< T, A >::my_array

protected

Definition at line 48 of file _flow_graph_item_buffer_impl.h.

Referenced by internal::item_buffer< OutputTuple >::clean_up_buffer(), internal::item_buffer< OutputTuple >::grow_my_array(), and internal::item_buffer< OutputTuple >::item().

my_array_size

template<typename T, typename A = cache_aligned_allocator<T>>

size_type internal::item_buffer< T, A >::my_array_size

protected

Definition at line 49 of file _flow_graph_item_buffer_impl.h.

Referenced by internal::item_buffer< OutputTuple >::capacity(), internal::item_buffer< OutputTuple >::clean_up_buffer(), internal::item_buffer< OutputTuple >::grow_my_array(), and internal::item_buffer< OutputTuple >::item().

my_head

template<typename T, typename A = cache_aligned_allocator<T>>

size_type internal::item_buffer< T, A >::my_head

protected

Definition at line 51 of file _flow_graph_item_buffer_impl.h.

Referenced by internal::item_buffer< OutputTuple >::buffer_empty(), internal::item_buffer< OutputTuple >::clean_up_buffer(), internal::item_buffer< OutputTuple >::destroy_front(), internal::item_buffer< OutputTuple >::front(), internal::item_buffer< OutputTuple >::grow_my_array(), internal::item_buffer< OutputTuple >::my_item_valid(), internal::item_buffer< OutputTuple >::pop_front(), internal::reservable_item_buffer< T, A >::release_front(), internal::reservable_item_buffer< T, A >::reserve_front(), and internal::item_buffer< OutputTuple >::size().

my_tail

template<typename T, typename A = cache_aligned_allocator<T>>

size_type internal::item_buffer< T, A >::my_tail

protected

Definition at line 52 of file _flow_graph_item_buffer_impl.h.

Referenced by internal::item_buffer< OutputTuple >::back(), internal::item_buffer< OutputTuple >::buffer_empty(), internal::item_buffer< OutputTuple >::clean_up_buffer(), internal::item_buffer< OutputTuple >::destroy_back(), internal::item_buffer< OutputTuple >::grow_my_array(), internal::item_buffer< OutputTuple >::my_item_valid(), internal::item_buffer< OutputTuple >::pop_back(), internal::item_buffer< OutputTuple >::push_back(), and internal::item_buffer< OutputTuple >::size().

---

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

• _flow_graph_item_buffer_impl.h