vulkan_display_detail::ConcurrentQueue< T, max_size > Class Template Reference

#include <concurrent_queue.hpp>

Inheritance diagram for vulkan_display_detail::ConcurrentQueue< T, max_size >:

Collaboration diagram for vulkan_display_detail::ConcurrentQueue< T, max_size >:

Public Member Functions
T	force_push (T item)
template<typename Rep , typename Period >
T	timed_pop (std::chrono::duration< Rep, Period > timeout)
T	try_pop ()
bool	try_push (T item)
T	wait_pop ()
void	wait_push (T item)

Private Member Functions
T	pop (bool nonblocking=false)
void	push_and_unlock (std::unique_lock< std::mutex > &lock, T &&item)

Private Attributes
std::mutex	mutex {}
std::queue< T >	queue
std::condition_variable	queue_decremented_cv {}
std::condition_variable	queue_incremented_cv {}

Detailed Description

template<typename T, size_t max_size = unlimited_size>
class vulkan_display_detail::ConcurrentQueue< T, max_size >

Definition at line 51 of file concurrent_queue.hpp.

Member Function Documentation

force_push()

template<typename T , size_t max_size = unlimited_size>

T vulkan_display_detail::ConcurrentQueue< T, max_size >::force_push ( T item )

inline

Definition at line 103 of file concurrent_queue.hpp.

                            {
                std::unique_lock lock{mutex};
                T result = {};
                if (queue.size() >= max_size) {
                        result = std::move(queue.front());
                        queue.pop();
                }
                push_and_unlock(lock, std::move(item));
                return result;
        }

References vulkan_display_detail::ConcurrentQueue< T, max_size >::push_and_unlock().

Here is the call graph for this function:

pop()

template<typename T , size_t max_size = unlimited_size>

T vulkan_display_detail::ConcurrentQueue< T, max_size >::pop ( bool nonblocking = false )

inlineprivate

Definition at line 63 of file concurrent_queue.hpp.

        {
                std::unique_lock<std::mutex> lock{mutex};
                if (queue.size() == 0 && nonblocking) {
                        return T();
                }
 
                queue_incremented_cv.wait(lock, [this]{return queue.size() > 0;});
                T result = std::move(queue.front());
                queue.pop();
 
                lock.unlock();
                queue_decremented_cv.notify_one();
                return result;
        }

References vulkan_display_detail::ConcurrentQueue< T, max_size >::queue_decremented_cv, and vulkan_display_detail::ConcurrentQueue< T, max_size >::queue_incremented_cv.

Referenced by vulkan_display_detail::ConcurrentQueue< T, max_size >::try_pop(), and vulkan_display_detail::ConcurrentQueue< T, max_size >::wait_pop().

push_and_unlock()

template<typename T , size_t max_size = unlimited_size>

void vulkan_display_detail::ConcurrentQueue< T, max_size >::push_and_unlock ( std::unique_lock< std::mutex > & lock, T && item )

inlineprivate

Definition at line 57 of file concurrent_queue.hpp.

                                                                      {
                queue.push(std::move(item));
                lock.unlock();
                queue_incremented_cv.notify_one();
        }

References vulkan_display_detail::ConcurrentQueue< T, max_size >::queue_incremented_cv.

Referenced by vulkan_display_detail::ConcurrentQueue< T, max_size >::force_push(), vulkan_display_detail::ConcurrentQueue< T, max_size >::try_push(), and vulkan_display_detail::ConcurrentQueue< T, max_size >::wait_push().

timed_pop()

template<typename T , size_t max_size = unlimited_size>

template<typename Rep , typename Period >

T vulkan_display_detail::ConcurrentQueue< T, max_size >::timed_pop ( std::chrono::duration< Rep, Period > timeout )

inline

Definition at line 88 of file concurrent_queue.hpp.

                                                           {
                std::unique_lock<std::mutex> lock{mutex};
 
                queue_incremented_cv.wait_for(lock, timeout, [this]{return queue.size() > 0;});
                if (queue.empty()){
                        return T{};
                }
                T result = std::move(queue.front());
                queue.pop();
 
                lock.unlock();
                queue_decremented_cv.notify_one();
                return result;
        }

References vulkan_display_detail::ConcurrentQueue< T, max_size >::queue_decremented_cv, and vulkan_display_detail::ConcurrentQueue< T, max_size >::queue_incremented_cv.

try_pop()

template<typename T , size_t max_size = unlimited_size>

T vulkan_display_detail::ConcurrentQueue< T, max_size >::try_pop ( )

inline

Definition at line 79 of file concurrent_queue.hpp.

                   {
                return pop(true);
        }

References vulkan_display_detail::ConcurrentQueue< T, max_size >::pop().

Here is the call graph for this function:

try_push()

template<typename T , size_t max_size = unlimited_size>

bool vulkan_display_detail::ConcurrentQueue< T, max_size >::try_push ( T item )

inline

Definition at line 114 of file concurrent_queue.hpp.

                             {
                std::unique_lock lock{mutex};
                if (queue.size() >= max_size) {
                        return false;
                }
                push_and_unlock(lock, std::move(item));
                return true;
        }

References vulkan_display_detail::ConcurrentQueue< T, max_size >::push_and_unlock().

Here is the call graph for this function:

wait_pop()

template<typename T , size_t max_size = unlimited_size>

T vulkan_display_detail::ConcurrentQueue< T, max_size >::wait_pop ( )

inline

Definition at line 83 of file concurrent_queue.hpp.

                    {
                return pop(false);
        }

References vulkan_display_detail::ConcurrentQueue< T, max_size >::pop().

Here is the call graph for this function:

wait_push()

template<typename T , size_t max_size = unlimited_size>

void vulkan_display_detail::ConcurrentQueue< T, max_size >::wait_push ( T item )

inline

Definition at line 123 of file concurrent_queue.hpp.

                              {
                std::unique_lock lock{mutex};
                if (max_size != unlimited_size) {
                        queue_decremented_cv.wait(lock, [this]{return queue.size() < max_size;});
                }
                push_and_unlock(lock, std::move(item));
        }

References vulkan_display_detail::ConcurrentQueue< T, max_size >::push_and_unlock(), vulkan_display_detail::ConcurrentQueue< T, max_size >::queue_decremented_cv, and vulkan_display_detail::unlimited_size.

Here is the call graph for this function:

Member Data Documentation

mutex

template<typename T , size_t max_size = unlimited_size>

std::mutex vulkan_display_detail::ConcurrentQueue< T, max_size >::mutex {}

mutableprivate

Definition at line 53 of file concurrent_queue.hpp.

{};

queue

template<typename T , size_t max_size = unlimited_size>

std::queue<T> vulkan_display_detail::ConcurrentQueue< T, max_size >::queue

private

Definition at line 52 of file concurrent_queue.hpp.

queue_decremented_cv

template<typename T , size_t max_size = unlimited_size>

std::condition_variable vulkan_display_detail::ConcurrentQueue< T, max_size >::queue_decremented_cv {}

private

Definition at line 54 of file concurrent_queue.hpp.

{};

Referenced by vulkan_display_detail::ConcurrentQueue< T, max_size >::pop(), vulkan_display_detail::ConcurrentQueue< T, max_size >::timed_pop(), and vulkan_display_detail::ConcurrentQueue< T, max_size >::wait_push().

queue_incremented_cv

template<typename T , size_t max_size = unlimited_size>

std::condition_variable vulkan_display_detail::ConcurrentQueue< T, max_size >::queue_incremented_cv {}

private

Definition at line 55 of file concurrent_queue.hpp.

{};

Referenced by vulkan_display_detail::ConcurrentQueue< T, max_size >::pop(), vulkan_display_detail::ConcurrentQueue< T, max_size >::push_and_unlock(), and vulkan_display_detail::ConcurrentQueue< T, max_size >::timed_pop().

---

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

• src/video_display/vulkan/concurrent_queue.hpp