I don't have much experience with the lockfree code and have a very newbie question about the use of relaxed memory load.
Would appreciate if someone more knowledgeable responds.

when do_push is called, I see relaxed load for node.next.  
do_push synchronise uses pool.construct
#ifndef BOOST_DOXYGEN_INVOKED template <bool Bounded> bool do_push(T const & t) { node * n = pool.template construct<true, Bounded>(t, pool.null_handle()); handle_type node_handle = pool.get_handle(n);
if (n == NULL) return false; // can this return spurious false
pool.construct uses relaxed check

        typedef typename detail::select_tagged_handle<node, node_based>::tagged_handle_type tagged_node_handle;
        typedef typename detail::select_tagged_handle<node, node_based>::handle_type handle_type;

        node(T const & v, handle_type null_handle):
            data(v)//, next(tagged_node_handle(0, 0))
            /* increment tag to avoid ABA problem */
            tagged_node_handle old_next = next.load(memory_order_relaxed);
            tagged_node_handle new_next (null_handle, old_next.get_next_tag());
            next.store(new_next, memory_order_release);

is it possible that pool has been added to but not visible in current thread and we get spurious pool full check

will this cause a race if other threads have added to the freelist and it is not visible to current thread?

Is there a discussion on thread safety of operations in the queue and freelist code?

I am specifically interested in fixed size queue.
With fixed size, the caller would have to check for failure so a race may not cause a big issue, but I just need to understand if that is an assumption that user is looping.