tbb::internal::mail_outbox Class Reference

Class representing where mail is put. More...

#include <mailbox.h>

Inheritance diagram for tbb::internal::mail_outbox:

Collaboration diagram for tbb::internal::mail_outbox:

Public Member Functions
bool	push (task_proxy *t)
	Push task_proxy onto the mailbox queue of another thread. More...
bool	empty ()
	Return true if mailbox is empty. More...
void	construct ()
	Construct *this as a mailbox from zeroed memory. More...
intptr_t	drain ()
	Drain the mailbox. More...
bool	recipient_is_idle ()
	True if thread that owns this mailbox is looking for work. More...

Private Member Functions
task_proxy *	internal_pop (__TBB_ISOLATION_EXPR(isolation_tag isolation))

Static Private Attributes
static const int	mailbox_task_limit = 32

Friends
class	mail_inbox

Additional Inherited Members
Private Types inherited from tbb::internal::unpadded_mail_outbox
typedef task_proxy *__TBB_atomic	proxy_ptr
Private Attributes inherited from tbb::internal::padded_base< unpadded_mail_outbox, NFS_MaxLineSize, sizeof(unpadded_mail_outbox) % NFS_MaxLineSize >
char	pad [S - R]
Private Attributes inherited from tbb::internal::unpadded_mail_outbox
proxy_ptr	my_first
	Pointer to first task_proxy in mailbox, or NULL if box is empty. More...
proxy_ptr *__TBB_atomic	my_last
	Pointer to pointer that will point to next item in the queue. Never NULL. More...
tbb::atomic< int >	my_task_count
	Approximate number of tasks in mailbox to prevent an unlimited grow when the owner is not available. More...
bool	my_is_idle
	Owner of mailbox is not executing a task, and has drained its own task pool. More...

Detailed Description

Class representing where mail is put.

Padded to occupy a cache line.

Definition at line 99 of file mailbox.h.

Member Function Documentation

construct()

void tbb::internal::mail_outbox::construct ( )

inline

Construct *this as a mailbox from zeroed memory.

Raise assertion if *this is not previously zeroed, or sizeof(this) is wrong. This method is provided instead of a full constructor since we know the object will be constructed in zeroed memory.

Definition at line 169 of file mailbox.h.

                     {
        __TBB_ASSERT( sizeof(*this)==NFS_MaxLineSize, NULL );
        __TBB_ASSERT( !my_first, NULL );
        __TBB_ASSERT( !my_last, NULL );
        __TBB_ASSERT( !my_is_idle, NULL );
        my_last=&my_first;
        suppress_unused_warning(pad);
    }

References __TBB_ASSERT, tbb::internal::unpadded_mail_outbox::my_first, tbb::internal::unpadded_mail_outbox::my_is_idle, tbb::internal::unpadded_mail_outbox::my_last, tbb::internal::NFS_MaxLineSize, tbb::internal::padded_base< unpadded_mail_outbox, NFS_MaxLineSize, sizeof(unpadded_mail_outbox) % NFS_MaxLineSize >::pad, and tbb::internal::suppress_unused_warning().

Referenced by tbb::internal::arena::arena().

Here is the call graph for this function:

Here is the caller graph for this function:

drain()

intptr_t tbb::internal::mail_outbox::drain ( )

inline

Drain the mailbox.

Definition at line 179 of file mailbox.h.

                     {
        intptr_t k = 0;
        // No fences here because other threads have already quit.
        for( ; task_proxy* t = my_first; ++k ) {
            my_first = t->next_in_mailbox;
            NFS_Free((char*)t - task_prefix_reservation_size);
        }
        return k;
    }

References tbb::internal::unpadded_mail_outbox::my_first, tbb::internal::task_proxy::next_in_mailbox, tbb::internal::NFS_Free(), and tbb::internal::task_prefix_reservation_size.

Referenced by tbb::internal::arena::free_arena().

Here is the call graph for this function:

Here is the caller graph for this function:

empty()

bool tbb::internal::mail_outbox::empty ( )

inline

Return true if mailbox is empty.

Definition at line 161 of file mailbox.h.

                 {
        return __TBB_load_relaxed(my_first) == NULL;
    }

References tbb::internal::__TBB_load_relaxed(), and tbb::internal::unpadded_mail_outbox::my_first.

Referenced by tbb::internal::mail_inbox::empty().

Here is the call graph for this function:

Here is the caller graph for this function:

internal_pop()

task_proxy* tbb::internal::mail_outbox::internal_pop ( __TBB_ISOLATION_EXPR(isolation_tag isolation)  )

inlineprivate

Definition at line 102 of file mailbox.h.

                                                                              {
        task_proxy* curr = __TBB_load_relaxed( my_first );
        if ( !curr )
            return NULL;
        task_proxy **prev_ptr = &my_first;
#if __TBB_TASK_ISOLATION
        if ( isolation != no_isolation ) {
            while ( curr->prefix().isolation != isolation ) {
                prev_ptr = &curr->next_in_mailbox;
                curr = curr->next_in_mailbox;
                if ( !curr )
                    return NULL;
            }
        }
#endif /* __TBB_TASK_ISOLATION */
        __TBB_control_consistency_helper(); // on my_first
        // There is a first item in the mailbox.  See if there is a second.
        if ( task_proxy* second = curr->next_in_mailbox ) {
            // There are at least two items, so first item can be popped easily.
            *prev_ptr = second;
        } else {
            // There is only one item.  Some care is required to pop it.
            *prev_ptr = NULL;
            if ( as_atomic( my_last ).compare_and_swap( prev_ptr, &curr->next_in_mailbox ) == &curr->next_in_mailbox ) {
                // Successfully transitioned mailbox from having one item to having none.
                __TBB_ASSERT( !curr->next_in_mailbox, NULL );
            } else {
                // Some other thread updated my_last but has not filled in first->next_in_mailbox
                // Wait until first item points to second item.
                atomic_backoff backoff;
                while ( !(second = curr->next_in_mailbox) ) backoff.pause();
                *prev_ptr = second;
            }
        }
        --my_task_count;
        __TBB_ASSERT( my_task_count >= 0, NULL );
        __TBB_ASSERT( curr, NULL );
        return curr;
    }

References __TBB_ASSERT, __TBB_control_consistency_helper, tbb::internal::__TBB_load_relaxed(), tbb::internal::as_atomic(), tbb::internal::unpadded_mail_outbox::my_first, tbb::internal::unpadded_mail_outbox::my_last, tbb::internal::unpadded_mail_outbox::my_task_count, tbb::internal::task_proxy::next_in_mailbox, tbb::internal::no_isolation, and tbb::internal::atomic_backoff::pause().

Referenced by tbb::internal::mail_inbox::pop().

Here is the call graph for this function:

Here is the caller graph for this function:

push()

bool tbb::internal::mail_outbox::push ( task_proxy *  t )

inline

Push task_proxy onto the mailbox queue of another thread.

Implementation is wait-free. Returns false if there are too many tasks.

Definition at line 147 of file mailbox.h.

                               {
        if (my_task_count > mailbox_task_limit)
            return false;
        ++my_task_count;
        __TBB_ASSERT(t, NULL);
        t->next_in_mailbox = NULL;
        proxy_ptr * const link = (proxy_ptr *)__TBB_FetchAndStoreW(&my_last,(intptr_t)&t->next_in_mailbox);
        // No release fence required for the next store, because there are no memory operations
        // between the previous fully fenced atomic operation and the store.
        __TBB_store_relaxed(*link, t);
        return true;
    }

References __TBB_ASSERT, tbb::internal::__TBB_store_relaxed(), mailbox_task_limit, tbb::internal::unpadded_mail_outbox::my_last, tbb::internal::unpadded_mail_outbox::my_task_count, and tbb::internal::task_proxy::next_in_mailbox.

Referenced by tbb::internal::generic_scheduler::prepare_for_spawning().

Here is the call graph for this function:

Here is the caller graph for this function:

recipient_is_idle()

bool tbb::internal::mail_outbox::recipient_is_idle ( )

inline

True if thread that owns this mailbox is looking for work.

Definition at line 190 of file mailbox.h.

                             {
        return my_is_idle;
    }

References tbb::internal::unpadded_mail_outbox::my_is_idle.

Referenced by tbb::internal::generic_scheduler::steal_task_from().

Here is the caller graph for this function:

Friends And Related Function Documentation

mail_inbox

friend class mail_inbox

friend

Definition at line 142 of file mailbox.h.

Member Data Documentation

mailbox_task_limit

const int tbb::internal::mail_outbox::mailbox_task_limit = 32

staticprivate

Definition at line 100 of file mailbox.h.

Referenced by push().

---

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

• mailbox.h