Threadpool Class Reference

#include <Threadpool.hpp>

Public Member Functions
	Threadpool (std::size_t numThreads, IRuntime *runtimePtr, std::vector< std::shared_ptr< IWorkingMemHandle >> memHandles)
	~Threadpool ()
void	LoadMemHandles (std::vector< std::shared_ptr< IWorkingMemHandle >> memHandles)
void	UnloadMemHandles (NetworkId networkId)
void	Schedule (NetworkId networkId, const InputTensors &inputTensors, const OutputTensors &outputTensors, const QosExecPriority priority, std::shared_ptr< IAsyncExecutionCallback > cb)
	Schedule an asynchronous execution on the loaded network. More...
void	TerminateThreadPool () noexcept

Detailed Description

Definition at line 30 of file Threadpool.hpp.

Constructor & Destructor Documentation

Threadpool()

Threadpool	(	std::size_t	numThreads,
		IRuntime *	runtimePtr,
		std::vector< std::shared_ptr< IWorkingMemHandle >>	memHandles
	)

Definition at line 16 of file Threadpool.cpp.

    : m_RuntimePtr(runtimePtr)
{
    for (auto i = 0u; i < numThreads; ++i)
    {
        m_Threads.emplace_back(std::make_unique<std::thread>(&Threadpool::ProcessExecPriorities, this, i));
    }
 
    LoadMemHandles(memHandles);
}

References Threadpool::LoadMemHandles().

~Threadpool()

~Threadpool ( )

inline

Definition at line 37 of file Threadpool.hpp.

    {
        TerminateThreadPool();
    }

References Threadpool::TerminateThreadPool().

Member Function Documentation

LoadMemHandles()

void LoadMemHandles

(

std::vector< std::shared_ptr< IWorkingMemHandle >>

memHandles

)

Definition at line 29 of file Threadpool.cpp.

{
    if (memHandles.size() == 0)
    {
        throw armnn::RuntimeException("Threadpool::UnloadMemHandles: Size of memHandles vector must be greater than 0");
    }
 
    if (memHandles.size() != m_Threads.size())
    {
        throw armnn::RuntimeException(
                "Threadpool::UnloadMemHandles: Size of memHandles vector must match the number of threads");
    }
 
    NetworkId networkId = memHandles[0]->GetNetworkId();
    for (uint32_t i = 1; i < memHandles.size(); ++i)
    {
        if (networkId != memHandles[i]->GetNetworkId())
        {
            throw armnn::RuntimeException(
                    "Threadpool::UnloadMemHandles: All network ids must be identical in memHandles");
        }
    }
 
    std::pair<NetworkId, std::vector<std::shared_ptr<IWorkingMemHandle>>> pair {networkId, memHandles};
 
    m_WorkingMemHandleMap.insert(pair);
}

Referenced by Threadpool::Threadpool().

Schedule()

void Schedule	(	NetworkId	networkId,
		const InputTensors &	inputTensors,
		const OutputTensors &	outputTensors,
		const QosExecPriority	priority,
		std::shared_ptr< IAsyncExecutionCallback >	cb
	)

Schedule an asynchronous execution on the loaded network.

Definition at line 69 of file Threadpool.cpp.

{
    if (m_WorkingMemHandleMap.find(networkId) == m_WorkingMemHandleMap.end())
    {
        throw armnn::RuntimeException("Threadpool::UnloadMemHandles: Unknown NetworkId");
    }
 
    // Group execution parameters so that they can be easily added to the queue
    ExecutionTuple groupExecParams = std::make_tuple(networkId, inputTensors, outputTensors, cb);
 
    std::shared_ptr<ExecutionTuple> operation = std::make_shared<ExecutionTuple>(groupExecParams);
 
    // Add a message to the queue and notify the request thread
    std::unique_lock<std::mutex> lock(m_ThreadPoolMutex);
    switch (priority)
    {
        case QosExecPriority::High:
            m_HighPriorityQueue.push(operation);
            break;
        case QosExecPriority::Low:
            m_LowPriorityQueue.push(operation);
            break;
        case QosExecPriority::Medium:
        default:
            m_MediumPriorityQueue.push(operation);
    }
    m_ThreadPoolEvent.notify_one();
}

References armnn::High, armnn::Low, and armnn::Medium.

TerminateThreadPool()

void TerminateThreadPool ( )

noexcept

Definition at line 102 of file Threadpool.cpp.

{
    {
        std::unique_lock<std::mutex> threadPoolLock(m_ThreadPoolMutex);
        m_TerminatePool = true;
    }
 
    m_ThreadPoolEvent.notify_all();
 
    for (auto &thread : m_Threads)
    {
        thread->join();
    }
}

Referenced by Threadpool::~Threadpool().

UnloadMemHandles()

void UnloadMemHandles

(

NetworkId

networkId

)

Definition at line 57 of file Threadpool.cpp.

{
    if (m_WorkingMemHandleMap.find(networkId) != m_WorkingMemHandleMap.end())
    {
        m_WorkingMemHandleMap.erase(networkId);
    }
    else
    {
       throw armnn::RuntimeException("Threadpool::UnloadMemHandles: Unknown NetworkId");
    }
}

---

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

• include/armnn/Threadpool.hpp
• src/armnn/Threadpool.cpp