What is the internal container used in tbb::concurrent_bounded_queue?

Question

I know that std::queue uses a std::deque by default as its internal container. I could not find the same info for TBB.

I have a legacy multithreaded application that currently uses a thread-safe wrapper around a std::queue<void*, std::list<void*>> to store relatively large objects (58 bytes). I am currently looking for better alternatives to improve performance.

One option is to get rid of the linked list and use the default std::deque as the internal container and switch from pointer-to-object to storing objects by value. std::deque being allocated in chunks would scale better memory-wise as no. of elements increase. Also having a few elements contiguous would be helpful from a cache perspective.

The other option is to use TBB's concurrent_bounded_queue. But I don't have enough information about that to know whether storing my object as value would be a feasible option.

Any alternative suggestions are also welcome.

Answer 1

You can store objects as value in tbb::concurrent_bounded_queue. You can refer to the below example code for implementation.

#include <tbb/concurrent_queue.h>
#include <tbb/concurrent_priority_queue.h>
#include <iostream>
    static int value=0;
    static int obj_count=0;       // count of objects 
class Myclass{
    public:

    int myarray[10];
    Myclass()
    {
        for(int i=0;i<10;i++){
            myarray[i]=value++;   //initializing the values of myarray for each new object
        }
        
    }
void show()
{
    std::cout<< " Values of object "<< (++obj_count ) <<" are: ";
    for(int i=0;i<10;i++){
        std::cout<<myarray[i]<<" "; // printing the data values of myarray object
    }
    std::cout<<std::endl;
}   
};

int main()
{
    Myclass m[10];
    tbb::concurrent_bounded_queue<Myclass> queue;  // creatiing a concurrent_bounded_queue of type "Myclass"
    for(int i=0;i<10;++i){
        queue.try_push(m[i]);  //pushing each Myclass object into the concurrent_bounded_queue
    }
    for(int i=0;i<10;i++){
    Myclass val;
        if(queue.try_pop(val)) //pops it from the queue, assigns it to destination, and destroys the original value.
        {
        val.show(); //To print/access the data of myarray for each popped Myclass object.
        }   
        }
    std::cout<< std::endl;
    return 0;
}

Compilation and execution can be done as shown in the screenshot link attached here-->. compilation and execution

I hope this might help you.

Thanks, Santosh