EIC code displayed by LXR master/​include/​oneapi/​tbb/​detail/​_flow_graph_item_buffer_impl.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-12-18 10:24:17

 /*
     Copyright (c) 2005-2024 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at
 
         http://www.apache.org/licenses/LICENSE-2.0
 
     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
 */
 
 #ifndef __TBB__flow_graph_item_buffer_impl_H
 #define __TBB__flow_graph_item_buffer_impl_H
 
 #ifndef __TBB_flow_graph_H
 #error Do not #include this internal file directly; use public TBB headers instead.
 #endif
 
 #include "_aligned_space.h"
 
 // in namespace tbb::flow::interfaceX (included in _flow_graph_node_impl.h)
 
 //! Expandable buffer of items.  The possible operations are push, pop,
 //* tests for empty and so forth.  No mutual exclusion is built in.
 //* objects are constructed into and explicitly-destroyed.  get_my_item gives
 // a read-only reference to the item in the buffer.  set_my_item may be called
 // with either an empty or occupied slot.
 
 template <typename T, typename A=cache_aligned_allocator<T> >
 class item_buffer {
 public:
     typedef T item_type;
     enum buffer_item_state { no_item=0, has_item=1, reserved_item=2 };
 protected:
     struct aligned_space_item {
         item_type item;
         buffer_item_state state;
 #if __TBB_PREVIEW_FLOW_GRAPH_TRY_PUT_AND_WAIT
         message_metainfo metainfo;
 #endif
     };
     typedef size_t size_type;
     typedef aligned_space<aligned_space_item> buffer_item_type;
     typedef typename allocator_traits<A>::template rebind_alloc<buffer_item_type> allocator_type;
     buffer_item_type *my_array;
     size_type my_array_size;
     static const size_type initial_buffer_size = 4;
     size_type my_head;
     size_type my_tail;
 
     bool buffer_empty() const { return my_head == my_tail; }
 
     aligned_space_item &element(size_type i) {
         __TBB_ASSERT(!(size_type(&(my_array[i&(my_array_size-1)].begin()->state))%alignment_of<buffer_item_state>::value), nullptr);
         __TBB_ASSERT(!(size_type(&(my_array[i&(my_array_size-1)].begin()->item))%alignment_of<item_type>::value), nullptr);
 #if __TBB_PREVIEW_FLOW_GRAPH_TRY_PUT_AND_WAIT
         __TBB_ASSERT(!(size_type(&(my_array[i&(my_array_size-1)].begin()->metainfo))%alignment_of<message_metainfo>::value), nullptr);
 #endif
         return *my_array[i & (my_array_size - 1) ].begin();
     }
 
     const aligned_space_item &element(size_type i) const {
         __TBB_ASSERT(!(size_type(&(my_array[i&(my_array_size-1)].begin()->state))%alignment_of<buffer_item_state>::value), nullptr);
         __TBB_ASSERT(!(size_type(&(my_array[i&(my_array_size-1)].begin()->item))%alignment_of<item_type>::value), nullptr);
 #if __TBB_PREVIEW_FLOW_GRAPH_TRY_PUT_AND_WAIT
         __TBB_ASSERT(!(size_type(&(my_array[i&(my_array_size-1)].begin()->metainfo))%alignment_of<message_metainfo>::value), nullptr);
 #endif
         return *my_array[i & (my_array_size-1)].begin();
     }
 
     bool my_item_valid(size_type i) const { return (i < my_tail) && (i >= my_head) && (element(i).state != no_item); }
 #if TBB_USE_ASSERT
     bool my_item_reserved(size_type i) const { return element(i).state == reserved_item; }
 #endif
 
     // object management in buffer
     const item_type &get_my_item(size_t i) const {
         __TBB_ASSERT(my_item_valid(i),"attempt to get invalid item");
         return element(i).item;
     }
 
 #if __TBB_PREVIEW_FLOW_GRAPH_TRY_PUT_AND_WAIT
     message_metainfo& get_my_metainfo(size_t i) {
         __TBB_ASSERT(my_item_valid(i), "attempt to get invalid item");
         return element(i).metainfo;
     }
 #endif
 
     // may be called with an empty slot or a slot that has already been constructed into.
     void set_my_item(size_t i, const item_type &o
                      __TBB_FLOW_GRAPH_METAINFO_ARG(const message_metainfo& metainfo))
     {
         if(element(i).state != no_item) {
             destroy_item(i);
         }
         new(&(element(i).item)) item_type(o);
         element(i).state = has_item;
 #if __TBB_PREVIEW_FLOW_GRAPH_TRY_PUT_AND_WAIT
         new(&element(i).metainfo) message_metainfo(metainfo);
 
         for (auto& waiter : metainfo.waiters()) {
             waiter->reserve(1);
         }
 #endif
     }
 
 #if __TBB_PREVIEW_FLOW_GRAPH_TRY_PUT_AND_WAIT
     void set_my_item(size_t i, const item_type& o, message_metainfo&& metainfo) {
         if(element(i).state != no_item) {
             destroy_item(i);
         }
 
         new(&(element(i).item)) item_type(o);
         new(&element(i).metainfo) message_metainfo(std::move(metainfo));
         // Skipping the reservation on metainfo.waiters since the ownership
         // is moving from metainfo to the cache
         element(i).state = has_item;
     }
 #endif
 
     // destructively-fetch an object from the buffer
 #if __TBB_PREVIEW_FLOW_GRAPH_TRY_PUT_AND_WAIT
     void fetch_item(size_t i, item_type& o, message_metainfo& metainfo) {
         __TBB_ASSERT(my_item_valid(i), "Trying to fetch an empty slot");
         o = get_my_item(i);  // could have std::move assign semantics
         metainfo = std::move(get_my_metainfo(i));
         destroy_item(i);
     }
 #else
     void fetch_item(size_t i, item_type &o) {
         __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);
     }
 #endif
 
     // move an existing item from one slot to another.  The moved-to slot must be unoccupied,
     // the moved-from slot must exist and not be reserved.  The after, from will be empty,
     // to will be occupied but not reserved
     void move_item(size_t to, size_t from) {
         __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");
         // could have std::move semantics
         set_my_item(to, get_my_item(from) __TBB_FLOW_GRAPH_METAINFO_ARG(get_my_metainfo(from)));
         destroy_item(from);
     }
 
     // put an item in an empty slot.  Return true if successful, else false
 #if __TBB_PREVIEW_FLOW_GRAPH_TRY_PUT_AND_WAIT
     template <typename Metainfo>
     bool place_item(size_t here, const item_type &me, Metainfo&& metainfo) {
 #if !TBB_DEPRECATED_SEQUENCER_DUPLICATES
         if(my_item_valid(here)) return false;
 #endif
         set_my_item(here, me, std::forward<Metainfo>(metainfo));
         return true;
     }
 #else
     bool place_item(size_t here, const item_type &me) {
 #if !TBB_DEPRECATED_SEQUENCER_DUPLICATES
         if(my_item_valid(here)) return false;
 #endif
         set_my_item(here, me);
         return true;
     }
 #endif
 
     // could be implemented with std::move semantics
     void swap_items(size_t i, size_t j) {
         __TBB_ASSERT(my_item_valid(i) && my_item_valid(j), "attempt to swap invalid item(s)");
         item_type temp = get_my_item(i);
 #if __TBB_PREVIEW_FLOW_GRAPH_TRY_PUT_AND_WAIT
         message_metainfo temp_metainfo = get_my_metainfo(i);
         set_my_item(i, get_my_item(j), get_my_metainfo(j));
         set_my_item(j, temp, temp_metainfo);
 #else
         set_my_item(i, get_my_item(j));
         set_my_item(j, temp);
 #endif
     }
 
     void destroy_item(size_type i) {
         __TBB_ASSERT(my_item_valid(i), "destruction of invalid item");
 
         auto& e = element(i);
         e.item.~item_type();
         e.state = no_item;
 
 #if __TBB_PREVIEW_FLOW_GRAPH_TRY_PUT_AND_WAIT
         for (auto& msg_waiter : e.metainfo.waiters()) {
             msg_waiter->release(1);
         }
 
         e.metainfo.~message_metainfo();
 #endif
     }
 
     // returns the front element
     const item_type& front() const
     {
         __TBB_ASSERT(my_item_valid(my_head), "attempt to fetch head non-item");
         return get_my_item(my_head);
     }
 
 #if __TBB_PREVIEW_FLOW_GRAPH_TRY_PUT_AND_WAIT
     const message_metainfo& front_metainfo() const
     {
         __TBB_ASSERT(my_item_valid(my_head), "attempt to fetch head non-item");
         return element(my_head).metainfo;
     }
 #endif
 
     // returns  the back element
     const item_type& back() const
     {
         __TBB_ASSERT(my_item_valid(my_tail - 1), "attempt to fetch head non-item");
         return get_my_item(my_tail - 1);
     }
 
 #if __TBB_PREVIEW_FLOW_GRAPH_TRY_PUT_AND_WAIT
     const message_metainfo& back_metainfo() const {
         __TBB_ASSERT(my_item_valid(my_tail - 1), "attempt to fetch head non-item");
         return element(my_tail - 1).metainfo;
     }
 #endif
 
     // following methods are for reservation of the front of a buffer.
     void reserve_item(size_type i) {
         __TBB_ASSERT(my_item_valid(i) && !my_item_reserved(i), "item cannot be reserved");
         element(i).state = reserved_item;
     }
 
     void release_item(size_type i) {
         __TBB_ASSERT(my_item_reserved(i), "item is not reserved");
         element(i).state = has_item;
     }
 
     void destroy_front() { destroy_item(my_head); ++my_head; }
     void destroy_back() { destroy_item(my_tail-1); --my_tail; }
 
     // we have to be able to test against a new tail value without changing my_tail
     // grow_array doesn't work if we change my_tail when the old array is too small
     size_type size(size_t new_tail = 0) { return (new_tail ? new_tail : my_tail) - my_head; }
     size_type capacity() { return my_array_size; }
     // sequencer_node does not use this method, so we don't
     // need a version that passes in the new_tail value.
     bool buffer_full() { return size() >= capacity(); }
 
     //! Grows the internal array.
     void grow_my_array( size_t minimum_size ) {
         // 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].begin()->state = 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)].begin()->item);
                 (void)new(new_space) item_type(get_my_item(i));
                 new_array[i&(new_size-1)].begin()->state = element(i).state;
 #if __TBB_PREVIEW_FLOW_GRAPH_TRY_PUT_AND_WAIT
                 char* meta_space = (char *)&(new_array[i&(new_size-1)].begin()->metainfo);
                 ::new(meta_space) message_metainfo(std::move(element(i).metainfo));
 #endif
             }
         }
 
         clean_up_buffer(/*reset_pointers*/false);
 
         my_array = new_array;
         my_array_size = new_size;
     }
 
     bool push_back(item_type& v
                    __TBB_FLOW_GRAPH_METAINFO_ARG(const message_metainfo& metainfo))
     {
         if (buffer_full()) {
             grow_my_array(size() + 1);
         }
         set_my_item(my_tail, v __TBB_FLOW_GRAPH_METAINFO_ARG(metainfo));
         ++my_tail;
         return true;
     }
 
     bool pop_back(item_type& v
                   __TBB_FLOW_GRAPH_METAINFO_ARG(message_metainfo& metainfo))
     {
         if (!my_item_valid(my_tail - 1)) {
             return false;
         }
         auto& e = element(my_tail - 1);
         v = e.item;
 #if __TBB_PREVIEW_FLOW_GRAPH_TRY_PUT_AND_WAIT
         metainfo = std::move(e.metainfo);
 #endif
 
         destroy_back();
         return true;
     }
 
     bool pop_front(item_type& v
                    __TBB_FLOW_GRAPH_METAINFO_ARG(message_metainfo& metainfo))
     {
         if (!my_item_valid(my_head)) {
             return false;
         }
         auto& e = element(my_head);
         v = e.item;
 #if __TBB_PREVIEW_FLOW_GRAPH_TRY_PUT_AND_WAIT
         metainfo = std::move(e.metainfo);
 #endif
 
         destroy_front();
         return true;
     }
 
 #if __TBB_PREVIEW_FLOW_GRAPH_TRY_PUT_AND_WAIT
     bool pop_back(item_type& v) {
         message_metainfo metainfo;
         return pop_back(v, metainfo);
     }
 
     bool pop_front(item_type& v) {
         message_metainfo metainfo;
         return pop_front(v, metainfo);
     }
 #endif
 
     // This is used both for reset and for grow_my_array.  In the case of grow_my_array
     // we want to retain the values of the head and tail.
     void clean_up_buffer(bool reset_pointers) {
         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 = nullptr;
         if(reset_pointers) {
             my_head = my_tail = my_array_size = 0;
         }
     }
 
 public:
     //! Constructor
     item_buffer( ) : my_array(nullptr), my_array_size(0),
                      my_head(0), my_tail(0) {
         grow_my_array(initial_buffer_size);
     }
 
     ~item_buffer() {
         clean_up_buffer(/*reset_pointers*/true);
     }
 
     void reset() { clean_up_buffer(/*reset_pointers*/true); grow_my_array(initial_buffer_size); }
 
 };
 
 //! item_buffer with reservable front-end.  NOTE: if reserving, do not
 //* complete operation with pop_front(); use consume_front().
 //* No synchronization built-in.
 template<typename T, typename A=cache_aligned_allocator<T> >
 class reservable_item_buffer : public item_buffer<T, A> {
 protected:
     using item_buffer<T, A>::my_item_valid;
     using item_buffer<T, A>::my_head;
 
 public:
     reservable_item_buffer() : item_buffer<T, A>(), my_reserved(false) {}
     void reset() {my_reserved = false; item_buffer<T,A>::reset(); }
 protected:
 
     bool reserve_front(T &v) {
         if(my_reserved || !my_item_valid(this->my_head)) return false;
         my_reserved = true;
         // reserving the head
         v = this->front();
         this->reserve_item(this->my_head);
         return true;
     }
 
 #if __TBB_PREVIEW_FLOW_GRAPH_TRY_PUT_AND_WAIT
     bool reserve_front(T& v, message_metainfo& metainfo) {
         if (my_reserved || !my_item_valid(this->my_head)) return false;
         my_reserved = true;
         // reserving the head
         v = this->front();
         metainfo = this->front_metainfo();
         this->reserve_item(this->my_head);
         return true;
     }
 #endif
 
     void consume_front() {
         __TBB_ASSERT(my_reserved, "Attempt to consume a non-reserved item");
         this->destroy_front();
         my_reserved = false;
     }
 
     void release_front() {
         __TBB_ASSERT(my_reserved, "Attempt to release a non-reserved item");
         this->release_item(this->my_head);
         my_reserved = false;
     }
 
     bool my_reserved;
 };
 
 #endif // __TBB__flow_graph_item_buffer_impl_H

This page was automatically generated by the 2.3.7 LXR engine. The LXR team