Method test

extern/libcds/test/stress/pqueue/pop.cpp:92–160

        template <class PQueue>
        void test( PQueue& q )
        {
            cds_test::thread_pool& pool = get_pool();

            // push
            {
                std::vector< size_t > arr;
                arr.reserve( s_nQueueSize );
                for ( size_t i = 0; i < s_nQueueSize; ++i )
                    arr.push_back( i );
                shuffle( arr.begin(), arr.end());

                size_t nPushError = 0;
                typedef typename PQueue::value_type value_type;
                for ( auto it = arr.begin(); it != arr.end(); ++it ) {
                    if ( !q.push( value_type( *it )))
                        ++nPushError;
                }
                s_nQueueSize -= nPushError;
            }

            propout() << std::make_pair( "thread_count", s_nThreadCount )
                << std::make_pair( "push_count", s_nQueueSize );

            // pop
            {
                pool.add( new Consumer<PQueue>( pool, q ), s_nThreadCount );

                std::chrono::milliseconds duration = pool.run();
                propout() << std::make_pair( "consumer_duration", duration );

                // Analyze result
                size_t nTotalPopped = 0;
                size_t nTotalError = 0;
                size_t nTotalErrorEq = 0;
                size_t nTotalFailed = 0;
                for ( size_t i = 0; i < pool.size(); ++i ) {
                    Consumer<PQueue>& cons = static_cast<Consumer<PQueue>&>( pool.get(i));

                    nTotalPopped  += cons.m_nPopSuccess;
                    nTotalError   += cons.m_nPopError;
                    nTotalErrorEq += cons.m_nPopErrorEq;
                    nTotalFailed  += cons.m_nPopFailed;

                    if ( !cons.m_arrFailedPops.empty()) {
                        std::cerr << "Priority violations, thread " << i;
                        for ( size_t k = 0; k < cons.m_arrFailedPops.size(); ++k ) {
                            std::cerr << "\n    " << "prev_key=" << cons.m_arrFailedPops[k].prev_key << " popped_key=" << cons.m_arrFailedPops[k].popped_key;
                            if ( cons.m_arrFailedPops[k].next_key != static_cast<size_t>(-1))
                                std::cerr << " next_key=" << cons.m_arrFailedPops[k].next_key;
                            else
                                std::cerr << " next_key unspecified";
                        }
                        std::cerr << std::endl;
                    }
                }

                propout()