PTL::TaskSubQueue Class Reference

#include <TaskSubQueue.hh>

Public Types
template<typename Tp >
using	container = std::list<Tp>
using	task_pointer = std::shared_ptr<VTask>
using	container_type = container<task_pointer>
using	size_type = container_type::size_type

Public Member Functions
	TaskSubQueue (std::atomic_uintmax_t *_ntasks)
	TaskSubQueue (const TaskSubQueue &)
	~TaskSubQueue ()=default
TaskSubQueue &	operator= (const TaskSubQueue &)=delete
int	GetId () const
bool	AcquireClaim ()
void	ReleaseClaim ()
void	PushTask (task_pointer &&) PTL_NO_SANITIZE_THREAD
task_pointer	PopTask (bool front=true) PTL_NO_SANITIZE_THREAD
size_type	size () const
bool	empty () const

Detailed Description

Definition at line 37 of file TaskSubQueue.hh.

Member Typedef Documentation

container

template<typename Tp >

using PTL::TaskSubQueue::container = std::list<Tp>

Definition at line 41 of file TaskSubQueue.hh.

container_type

using PTL::TaskSubQueue::container_type = container<task_pointer>

Definition at line 44 of file TaskSubQueue.hh.

size_type

using PTL::TaskSubQueue::size_type = container_type::size_type

Definition at line 45 of file TaskSubQueue.hh.

task_pointer

using PTL::TaskSubQueue::task_pointer = std::shared_ptr<VTask>

Definition at line 43 of file TaskSubQueue.hh.

Constructor & Destructor Documentation

TaskSubQueue() [1/2]

PTL::TaskSubQueue::TaskSubQueue ( std::atomic_uintmax_t * _ntasks )

inline

Definition at line 83 of file TaskSubQueue.hh.

: m_ntasks(0)
, m_available(true)
, m_all_tasks(_ntasks)
{}

TaskSubQueue() [2/2]

PTL::TaskSubQueue::TaskSubQueue ( const TaskSubQueue & rhs )

inline

Definition at line 91 of file TaskSubQueue.hh.

: m_ntasks(0)
, m_available(true)
, m_all_tasks(rhs.m_all_tasks)
{}

~TaskSubQueue()

PTL::TaskSubQueue::~TaskSubQueue ( )

default

Member Function Documentation

AcquireClaim()

bool PTL::TaskSubQueue::AcquireClaim ( )

inline

Definition at line 100 of file TaskSubQueue.hh.

{
    bool is_avail = m_available.load(std::memory_order_relaxed);
    if(!is_avail)
        return false;
    return m_available.compare_exchange_strong(is_avail, false,
                                               std::memory_order_relaxed);
}

Referenced by PTL::UserTaskQueue::GetTask(), PTL::UserTaskQueue::GetThreadBinTask(), and PTL::UserTaskQueue::InsertTask().

empty()

bool PTL::TaskSubQueue::empty ( ) const

inline

Definition at line 130 of file TaskSubQueue.hh.

{
    return (m_ntasks.load() == 0);
}

Referenced by PTL::UserTaskQueue::GetTask(), and PTL::UserTaskQueue::GetThreadBinTask().

GetId()

int PTL::TaskSubQueue::GetId

(

)

const

operator=()

TaskSubQueue & PTL::TaskSubQueue::operator= ( const TaskSubQueue & )

delete

PopTask()

TaskSubQueue::task_pointer PTL::TaskSubQueue::PopTask ( bool front = true )

inline

Definition at line 152 of file TaskSubQueue.hh.

{
    // no need to lock -- claim is acquired via atomic
    assert(m_available.load(std::memory_order_relaxed) == false);
    if(m_ntasks.load() == 0)
        return nullptr;
 
    task_pointer _task{ nullptr };
    if(front)
    {
#if defined(PTL_USE_LOCKS)
        AutoLock lk{ m_mutex };
#endif
        _task = std::move(m_task_queue.front());
        m_task_queue.pop_front();
    }
    else
    {
#if defined(PTL_USE_LOCKS)
        AutoLock lk{ m_mutex };
#endif
        _task = std::move(m_task_queue.back());
        m_task_queue.pop_back();
    }
    --m_ntasks;
 
    return _task;
}

Referenced by PTL::UserTaskQueue::GetTask(), and PTL::UserTaskQueue::GetThreadBinTask().

PushTask()

void PTL::TaskSubQueue::PushTask ( task_pointer && task )

inline

Definition at line 138 of file TaskSubQueue.hh.

{
    // no need to lock these if claim is acquired via atomic
    assert(m_available.load(std::memory_order_relaxed) == false);
    ++m_ntasks;
#if defined(PTL_USE_LOCKS)
    AutoLock lk{ m_mutex };
#endif
    m_task_queue.emplace_front(std::move(task));
}

Referenced by PTL::UserTaskQueue::InsertTask().

ReleaseClaim()

void PTL::TaskSubQueue::ReleaseClaim ( )

inline

Definition at line 112 of file TaskSubQueue.hh.

{
    // if(m_available.load(std::memory_order_relaxed))
    //    return;
    m_available.store(true, std::memory_order_release);
}

Referenced by PTL::UserTaskQueue::GetTask(), PTL::UserTaskQueue::GetThreadBinTask(), and PTL::UserTaskQueue::InsertTask().

size()

TaskSubQueue::size_type PTL::TaskSubQueue::size ( ) const

inline

Definition at line 122 of file TaskSubQueue.hh.

{
    return m_ntasks.load();
}

---

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

• TaskSubQueue.hh