Interface class used to easily multithread a child class. More...

#include <AutonomyThread.hpp>

Collaboration diagram for AutonomyThread< T >:

[legend]

Public Types
enum class	AutonomyThreadState { eStarting , eRunning , eStopping , eStopped }

enum class	AutonomyThreadPriority { eLowest = BS::pr::lowest , eLow = BS::pr::low , eNormal = BS::pr::normal , eHigh = BS::pr::high , eHighest = BS::pr::highest }

Public Member Functions
	AutonomyThread ()
	Construct a new Autonomy Thread object.

virtual	~AutonomyThread ()
	Destroy the Autonomy Thread object. If the parent object or main thread is destroyed or exited while this thread is still running, a race condition will occur. Stopping and joining the thread here insures that the main program can't exit if the user forgot to stop and join the thread.

void	Start ()
	When this method is called, it starts a new thread that runs the code within the ThreadedContinuousCode method. This is the users main code that will run the important and continuous code for the class.

void	RequestStop ()
	Signals threads to stop executing user code, terminate. DOES NOT JOIN. This method will not force the thread to exit, if the user code is not written properly and contains WHILE statement or any other long-executing or blocking code, then the thread will not exit until the next iteration.

void	Join ()
	Waits for thread to finish executing and then closes thread. This method will block the calling code until thread is finished.

bool	Joinable () const
	Check if the code within the thread and all pools created by it are finished executing and the thread is ready to be closed.

AutonomyThreadState	GetThreadState () const
	Accessor for the Threads State private member.

std::string	GetThreadUUID () const
	Accessor for the Thread U U I D private member.

IPS &	GetIPS ()
	Accessor for the Frame I P S private member.

void	SetMainThreadPriority (AutonomyThreadPriority ePriority)
	Set the OS priority for the main continuous thread.

void	SetPoolThreadPriority (AutonomyThreadPriority ePriority)
	Set the OS priority for the highly parallelized pool threads.

Protected Member Functions
void	RunPool (const unsigned int nNumTasksToQueue, const unsigned int nNumThreads=2, const bool bForceStopCurrentThreads=false)
	When this method is called, it starts/adds tasks to a thread pool that runs nNumTasksToQueue copies of the code within the PooledLinearCode() method using nNumThreads number of threads. This is meant to be used as an internal utility of the child class to further improve parallelization. Default value for nNumThreads is 2.

void	RunDetachedPool (const unsigned int nNumTasksToQueue, const unsigned int nNumThreads=2, const bool bForceStopCurrentThreads=false)
	When this method is called, it starts a thread pool full of threads that don't return std::futures (like a placeholder for the thread return type). This means the thread will not have a return type and there is no way to determine if the thread has finished other than calling the Join() method. Only use this if you want to 'set and forget'. It will be faster as it doesn't return futures. Runs PooledLinearCode() method code. This is meant to be used as an internal utility of the child class to further improve parallelization.

template<typename N , typename F >
void	ParallelizeLoop (const int nNumThreads, const N tTotalIterations, F &&tLoopFunction)
	Given a ref-qualified looping function and an arbitrary number of iterations, this method will divide up the loop and run each section in a thread pool. This function must not return anything. This method will block until the loop has completed.

void	ClearPoolQueue ()
	Clears any tasks waiting to be ran in the queue, tasks currently running will remain running.

void	JoinPool ()
	Waits for pool to finish executing tasks. This method will block the calling code until thread is finished.

bool	PoolJoinable () const
	Check if the internal pool threads are done executing code and the queue is empty.

void	SetMainThreadIPSLimit (int nMaxIterationsPerSecond=0)
	Mutator for the Main Thread Max I P S private member.

int	GetPoolNumOfThreads ()
	Accessor for the Pool Num Of Threads private member.

int	GetPoolQueueLength ()
	Accessor for the Pool Queue Size private member.

std::vector< T >	GetPoolResults ()
	Accessor for the Pool Results private member. The action of getting results will destroy and remove them from this object. This method blocks if the thread is not finished, so no need to call JoinPool() before getting results.

int	GetMainThreadMaxIPS () const
	Accessor for the Main Thread Max I P S private member.

Protected Attributes
IPS	m_IPS = IPS()

Private Member Functions
virtual void	ThreadedContinuousCode ()=0

virtual T	PooledLinearCode ()=0

void	RunThread (std::atomic_bool &bStopThread)
	This method is ran in a separate thread. It is a middleware between the class member thread and the user code that handles graceful stopping of user code. This method is intentionally designed to not return anything.

std::string	GenerateUUIDV4 ()
	Generates a random UUID v4 string. This is useful for generating unique IDs for files, threads, or any other objects that need to be uniquely identified.

Private Attributes
BS::pr	m_eMainThreadPriority = BS::pr::normal

BS::pr	m_ePoolThreadPriority = BS::pr::normal

BS::thread_pool< BS::tp::pause >	m_thMainThread = BS::thread_pool<BS::tp::pause>(1)

BS::thread_pool< BS::tp::pause >	m_thPool = BS::thread_pool<BS::tp::pause>(2)

std::vector< std::future< T > >	m_vPoolReturns

std::atomic_bool	m_bStopThreads

std::atomic< AutonomyThreadState >	m_eThreadState

std::mutex	m_muThreadRunningConditionMutex

std::condition_variable	m_cdThreadRunningCondition

int	m_nMainThreadMaxIterationPerSecond

std::string	m_szThreadUUID

Detailed Description

template<class T>
class AutonomyThread< T >

Interface class used to easily multithread a child class.

Template Parameters

T	- Variable return type of internal pooled code.

Author: ClayJay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-07-27

Member Enumeration Documentation

◆ AutonomyThreadState

template<class T >

enum class AutonomyThread::AutonomyThreadState

strong

        {
            eStarting,
            eRunning,
            eStopping,
            eStopped
        };

◆ AutonomyThreadPriority

template<class T >

enum class AutonomyThread::AutonomyThreadPriority

strong

        {
            eLowest = BS::pr::lowest,     // Thread will be scheduled less often and may not be able to reach the max IPS if the system is under heavy load.
            eLow    = BS::pr::low,        // Thread will be scheduled less often and may not be able to reach the max IPS if the system is under heavy load.
            eNormal = BS::pr::normal,     // Default. Thread will be scheduled normally and should be able to reach the max IPS if the system is not under heavy load.
            eHigh   = BS::pr::high,       // Thread will be scheduled more often and should be able to reach the max IPS even if the system is under
                                          // heavy load, but it may starve other threads of CPU time.
            eHighest = BS::pr::highest    // Thread will be scheduled as often as possible and should be able to reach the max IPS even if the system is under heavy load.
        };

Constructor & Destructor Documentation

◆ AutonomyThread()

template<class T >

AutonomyThread< T >::AutonomyThread ( )

inline

Construct a new Autonomy Thread object.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-12-30

        {
            // Initialize member variables.
            m_bStopThreads                     = false;
            m_eThreadState                     = AutonomyThreadState::eStopped;
            m_nMainThreadMaxIterationPerSecond = 0;
 
            // Generate a random UUID for this thread.
            m_szThreadUUID = this->GenerateUUIDV4();
        }

Here is the call graph for this function:

◆ ~AutonomyThread()

template<class T >

virtual AutonomyThread< T >::~AutonomyThread ( )

inlinevirtual

Destroy the Autonomy Thread object. If the parent object or main thread is destroyed or exited while this thread is still running, a race condition will occur. Stopping and joining the thread here insures that the main program can't exit if the user forgot to stop and join the thread.

Author: ClayJay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-07-23

        {
            // Tell all threads to stop executing user code.
            m_bStopThreads = true;
            // Update thread state.
            m_eThreadState = AutonomyThreadState::eStopping;
 
            // Pause and clear pool queues.
            m_thPool.pause();
            m_thPool.purge();
            m_thMainThread.pause();
            m_thMainThread.purge();
 
            // Wait for all pools to finish.
            m_thPool.wait();
            m_thMainThread.wait();
            // Update thread state.
            m_eThreadState = AutonomyThreadState::eStopped;
        }

Here is the call graph for this function:

Member Function Documentation

◆ Start()

template<class T >

void AutonomyThread< T >::Start ( )

inline

When this method is called, it starts a new thread that runs the code within the ThreadedContinuousCode method. This is the users main code that will run the important and continuous code for the class.

If this method is called directly after itself, RunPool(), or RunDetachedPool(), it will signal for those threads to stop and wait until they exit on their next iteration. Any number of tasks that are still queued will be cleared. Old results will be destroyed. If you want to wait until they fully execute their code, then call the Join() method before starting a new thread.

Note: This method will block until the thread state is eRunning.

Author: ClayJay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-07-22

        {
            // Tell any open thread to stop.
            m_bStopThreads = true;
            // Update thread state.
            m_eThreadState = AutonomyThreadState::eStopping;
 
            // Pause queuing of new tasks to the threads, then purge them.
            m_thPool.pause();
            m_thPool.purge();
            m_thMainThread.pause();
            m_thMainThread.purge();
 
            // Wait for loop, pool and main thread to join.
            this->Join();
 
            // Update thread state.
            m_eThreadState = AutonomyThreadState::eStarting;
            // Clear results vector.
            m_vPoolReturns.clear();
            // Reset thread stop toggle.
            m_bStopThreads = false;
 
            // Submit single task to pool queue and store resulting future. Still using pool, as it's scheduling is more efficient.
            std::future<void> fuMainReturn = m_thMainThread.submit_task(
                [this]()
                {
                    // Note: BS::this_thread::set_os_thread_priority was completely removed in BS v5.1.0.
                    // Priority is kept in memory but not applied to OS threads natively by the library anymore.
                    this->RunThread(m_bStopThreads);
                });
 
            // Unpause pool queues.
            m_thPool.unpause();
            m_thMainThread.unpause();
 
            // Block until thread is started or currently stopping if thread start failed.
            std::unique_lock<std::mutex> lkStartLock(m_muThreadRunningConditionMutex);
            m_cdThreadRunningCondition.wait(lkStartLock,
                                            [this]
                                            { return this->m_eThreadState == AutonomyThreadState::eRunning || this->m_eThreadState == AutonomyThreadState::eStopping; });
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RequestStop()

template<class T >

void AutonomyThread< T >::RequestStop ( )

inline

Signals threads to stop executing user code, terminate. DOES NOT JOIN. This method will not force the thread to exit, if the user code is not written properly and contains WHILE statement or any other long-executing or blocking code, then the thread will not exit until the next iteration.

Author: ClayJay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-07-22

        {
            // Signal for any open threads to stop executing,
            m_bStopThreads = true;
            // Update thread state.
            m_eThreadState = AutonomyThreadState::eStopping;
        }

Here is the caller graph for this function:

◆ Join()

template<class T >

void AutonomyThread< T >::Join ( )

inline

Waits for thread to finish executing and then closes thread. This method will block the calling code until thread is finished.

Author: ClayJay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-07-22

        {
            // Wait for pool to finish all tasks.
            m_thPool.wait();
            // Wait for main thread to finish.
            m_thMainThread.wait();
 
            // Update thread state.
            m_eThreadState = AutonomyThreadState::eStopped;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Joinable()

template<class T >

bool AutonomyThread< T >::Joinable ( ) const

inline

Check if the code within the thread and all pools created by it are finished executing and the thread is ready to be closed.

Returns: true - The thread is finished and joinable.; false - The thread is still running code.

Author: ClayJay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-07-22

        {    // Check current number of running and queued tasks.
            return (m_thMainThread.get_tasks_total() <= 0 && m_thPool.get_tasks_total() <= 0);
        }

Here is the call graph for this function:

◆ GetThreadState()

template<class T >

AutonomyThreadState AutonomyThread< T >::GetThreadState ( ) const

inline

Accessor for the Threads State private member.

Returns: AutonomyThreadState - The current state of the main thread.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2024-01-08

237{ return m_eThreadState; }

◆ GetThreadUUID()

template<class T >

std::string AutonomyThread< T >::GetThreadUUID ( ) const

inline

Accessor for the Thread U U I D private member.

Returns: std::string - The randomly generated UUID for this thread, used for logging and debugging.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2026-04-21

247{ return m_szThreadUUID; }

◆ GetIPS()

template<class T >

IPS & AutonomyThread< T >::GetIPS ( )

inline

Accessor for the Frame I P S private member.

Returns: IPS& - The iteration per second counter for the ThreadedContinuousCode()

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-08-20

257{ return m_IPS; }

Here is the caller graph for this function:

◆ SetMainThreadPriority()

template<class T >

void AutonomyThread< T >::SetMainThreadPriority ( AutonomyThreadPriority ePriority )

inline

Set the OS priority for the main continuous thread.

Parameters

thPriority - The OS thread priority to set.

Note: This will take effect the next time Start() is called.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2026-03-21

269{ m_eMainThreadPriority = static_cast<BS::pr>(ePriority); }

BS::pr

pr

An enum containing some pre-defined priorities for convenience.

Definition BS_thread_pool.hpp:398

◆ SetPoolThreadPriority()

template<class T >

void AutonomyThread< T >::SetPoolThreadPriority ( AutonomyThreadPriority ePriority )

inline

Set the OS priority for the highly parallelized pool threads.

Parameters

thPriority - The OS thread priority to set.

Note: This immediately resets the pool and applies the priority.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2026-03-21

        {
            // Update member variable.
            m_ePoolThreadPriority = static_cast<BS::pr>(ePriority);
            // Native OS priority extensions were removed in BS v5.1.0, so we just reset thread count.
            m_thPool.reset(m_thPool.get_thread_count());
        }

Here is the call graph for this function:

◆ RunPool()

template<class T >

void AutonomyThread< T >::RunPool	(	const unsigned int	nNumTasksToQueue,
		const unsigned int	nNumThreads = `2`,
		const bool	bForceStopCurrentThreads = `false`
	)

inlineprotected

When this method is called, it starts/adds tasks to a thread pool that runs nNumTasksToQueue copies of the code within the PooledLinearCode() method using nNumThreads number of threads. This is meant to be used as an internal utility of the child class to further improve parallelization. Default value for nNumThreads is 2.

If this method is called directly after itself or RunDetachedPool(), it will just add more tasks to the queue. If the bForceStopCurrentThreads is enabled, it will signal for those threads to stop and wait until they exit on their next iteration. Any number of tasks that are still queued will be cleared. Old results will be destroyed. If you want to wait until they fully execute their code, then call the Join() method before this one.

Once the pool is created it stays alive for as long as the program runs or until a different threading method is called. So there's no overhead with starting and stopping threads or queueing more tasks.

YOU MUST HANDLE MUTEX LOCKS AND ATOMICS. It is impossible for this class to handle locks as all possible solutions lead to a solution that only lets one thread run at a time, essentially canceling out the parallelism.

Parameters

nNumTasksToQueue	- The number of tasks running PooledLinearCode() to queue.
nNumThreads	- The number of threads to run user code in.
bForceStopCurrentThreads	- Clears the current tasks queue then signals and waits for existing tasks to stop before queueing more.

Author: ClayJay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-07-23

        {
            // Check if the pools need to be resized.
            if (m_thPool.get_thread_count() != nNumThreads)
            {
                // Pause queuing of new tasks to the threads, then purge them.
                m_thPool.pause();
                m_thPool.purge();
                // Wait for open threads to terminate, then resize the pool.
                m_thPool.reset(nNumThreads);
                // Unpause queue.
                m_thPool.unpause();
 
                // Clear results vector.
                m_vPoolReturns.clear();
            }
            // Check if the current pool tasks should be stopped before queueing more tasks.
            else if (bForceStopCurrentThreads)
            {
                // Pause queuing of new tasks to the threads, then purge them.
                m_thPool.pause();
                m_thPool.purge();
                // Wait for threadpool to join.
                m_thPool.wait();
                // Unpause queue.
                m_thPool.unpause();
            }
 
            // Loop nNumThreads times and queue tasks.
            for (unsigned int nIter = 0; nIter < nNumTasksToQueue; ++nIter)
            {
                // Submit single task to pool queue.
                m_vPoolReturns.emplace_back(m_thPool.submit_task(
                    [this]()
                    {
                        // Run user pool code without lock.
                        this->PooledLinearCode();
                    }));
            }
        }

Here is the call graph for this function:

◆ RunDetachedPool()

template<class T >

void AutonomyThread< T >::RunDetachedPool	(	const unsigned int	nNumTasksToQueue,
		const unsigned int	nNumThreads = `2`,
		const bool	bForceStopCurrentThreads = `false`
	)

inlineprotected

When this method is called, it starts a thread pool full of threads that don't return std::futures (like a placeholder for the thread return type). This means the thread will not have a return type and there is no way to determine if the thread has finished other than calling the Join() method. Only use this if you want to 'set and forget'. It will be faster as it doesn't return futures. Runs PooledLinearCode() method code. This is meant to be used as an internal utility of the child class to further improve parallelization.

If this method is called directly after itself or RunPool(), it will just add more tasks to the queue. If the bForceStopCurrentThreads is enabled, it will signal for those threads to stop and wait until they exit on their next iteration. Any number of tasks that are still queued will be cleared. Old results will be destroyed. If you want to wait until they fully execute their code, then call the Join() method before this one.

Once the pool is created it stays alive for as long as the program runs or until a different threading method is called. So there's no overhead with starting and stopping threads or queueing more tasks.

YOU MUST HANDLE MUTEX LOCKS AND ATOMICS. It is impossible for this class to handle locks as all possible solutions lead to a solution that only lets one thread run at a time, essentially canceling out the parallelism.

Parameters

nNumTasksToQueue	- The number of tasks running PooledLinearCode() to queue.
nNumThreads	- The number of threads to run user code in.
bForceStopCurrentThreads	- Clears the current tasks queue then signals and waits for existing tasks to stop before queueing more.

Author: ClayJay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-07-23

        {
            // Check if the pools need to be resized.
            if (m_thPool.get_thread_count() != nNumThreads)
            {
                // Pause queuing of new tasks to the threads, then purge them.
                m_thPool.pause();
                m_thPool.purge();
                // Wait for open threads to terminate, then resize the pool.
                m_thPool.reset(nNumThreads);
                // Unpause queue.
                m_thPool.unpause();
 
                // Clear results vector.
                m_vPoolReturns.clear();
            }
            // Check if the current pool tasks should be stopped before queueing more tasks.
            else if (bForceStopCurrentThreads)
            {
                // Pause queuing of new tasks to the threads, then purge them.
                m_thPool.pause();
                m_thPool.purge();
                // Wait for threadpool to join.
                m_thPool.wait();
                // Unpause queue.
                m_thPool.unpause();
            }
 
            // Loop nNumThreads times and queue tasks.
            for (unsigned int nIter = 0; nIter < nNumTasksToQueue; ++nIter)
            {
                // Push single task to pool queue. No return value no control.
                m_thPool.detach_task(
                    [this]()
                    {
                        // Run user code without lock.
                        this->PooledLinearCode();
                    });
            }
        }

Here is the call graph for this function:

◆ ParallelizeLoop()

template<class T >

template<typename N , typename F >

void AutonomyThread< T >::ParallelizeLoop	(	const int	nNumThreads,
		const N	tTotalIterations,
		F &&	tLoopFunction
	)

inlineprotected

Given a ref-qualified looping function and an arbitrary number of iterations, this method will divide up the loop and run each section in a thread pool. This function must not return anything. This method will block until the loop has completed.

To see an example of how to use this function, check out ArucoGenerateTags in the threads example folder.

YOU MUST HANDLE MUTEX LOCKS AND ATOMICS. It is impossible for this class to handle locks as all possible solutions lead to a solution that only lets one thread run at a time, essentially canceling out the parallelism.

Template Parameters

N	- Template argument for the nTotalIterations type.
F	- Template argument for the given function reference.

Parameters

nNumThreads	- The number of threads to use for the thread pool.
nTotalIterations	- The total iterations to loop for.
tLoopFunction	- Ref-qualified function to run. MUST ACCEPT TWO ARGS: const int a, const int b. a - loop start b - loop end

Author: ClayJay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-07-26

        {
            // Create new thread pool (no specific template flags needed for basic detaching).
            BS::thread_pool<> m_thLoopPool(nNumThreads);
 
            m_thLoopPool.detach_blocks(0,
                                       tTotalIterations,
                                       [&tLoopFunction](const int nStart, const int nEnd)
                                       {
                                           // Call loop function without lock.
                                           tLoopFunction(nStart, nEnd);
                                       });
 
            // Wait for loop to finish.
            m_thLoopPool.wait();
        }

Here is the call graph for this function:

◆ ClearPoolQueue()

template<class T >

void AutonomyThread< T >::ClearPoolQueue ( )

inlineprotected

Clears any tasks waiting to be ran in the queue, tasks currently running will remain running.

Author: ClayJay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-09-09

492{ m_thPool.purge(); }

Here is the call graph for this function:

◆ JoinPool()

template<class T >

void AutonomyThread< T >::JoinPool ( )

inlineprotected

Waits for pool to finish executing tasks. This method will block the calling code until thread is finished.

Author: ClayJay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-07-22

502{ m_thPool.wait(); }

Here is the call graph for this function:

◆ PoolJoinable()

template<class T >

bool AutonomyThread< T >::PoolJoinable ( ) const

inlineprotected

Check if the internal pool threads are done executing code and the queue is empty.

Returns: true - The thread is finished and joinable.; false - The thread is still running code.

Author: ClayJay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-07-22

        {
            // Check current number of running and queued tasks.
            return (m_thPool.get_tasks_total() <= 0);
        }

Here is the call graph for this function:

◆ SetMainThreadIPSLimit()

template<class T >

void AutonomyThread< T >::SetMainThreadIPSLimit ( int nMaxIterationsPerSecond = 0 )

inlineprotected

Mutator for the Main Thread Max I P S private member.

Parameters

nMaxIterationsPerSecond - The max iteration per second limit of the main thread.

Note: - Set to zero to disable the max iteration per second limit.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-12-30

        {
            // Assign member variable.
            m_nMainThreadMaxIterationPerSecond = nMaxIterationsPerSecond;
        }

◆ GetPoolNumOfThreads()

template<class T >

int AutonomyThread< T >::GetPoolNumOfThreads ( )

inlineprotected

Accessor for the Pool Num Of Threads private member.

Returns: int - The number of threads available to the pool.

Author: ClayJay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-09-09

544{ return m_thPool.get_thread_count(); }

Here is the call graph for this function:

◆ GetPoolQueueLength()

template<class T >

int AutonomyThread< T >::GetPoolQueueLength ( )

inlineprotected

Accessor for the Pool Queue Size private member.

Returns: int - The number of tasks queued for the pool.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2024-03-14

554{ return m_thPool.get_tasks_queued(); }

BS::thread_pool::get_tasks_queued

std::size_t get_tasks_queued() const

Get the number of tasks currently waiting in the queue to be executed by the threads.

Definition BS_thread_pool.hpp:1659

Here is the call graph for this function:

◆ GetPoolResults()

template<class T >

std::vector< T > AutonomyThread< T >::GetPoolResults ( )

inlineprotected

Accessor for the Pool Results private member. The action of getting results will destroy and remove them from this object. This method blocks if the thread is not finished, so no need to call JoinPool() before getting results.

Returns: std::vector<T> - A vector containing the returns from each thread that ran the PooledLinearCode.

Author: ClayJay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-07-26

        {
            // Create instance variable.
            std::vector<T> vResults;
 
            // Loop the pool futures and get result.
            for (std::future<T> fResult : m_vPoolReturns)
            {
                // Store returned value.
                vResults.emplace_back(fResult.get());
            }
 
            // Clear pool returns member variable.
            m_vPoolReturns.clear();
 
            return vResults;
        }

◆ GetMainThreadMaxIPS()

template<class T >

int AutonomyThread< T >::GetMainThreadMaxIPS ( ) const

inlineprotected

Accessor for the Main Thread Max I P S private member.

Returns: int - The max iterations per second the main thread can reach.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-12-31

        {
            // Return member variable value.
            return m_nMainThreadMaxIterationPerSecond;
        }

◆ ThreadedContinuousCode()

template<class T >

virtual void AutonomyThread< T >::ThreadedContinuousCode ( )

privatepure virtual

Implemented in BasicCamera, ArucoGenerateTagsThreaded, PrimeCalculatorThread, RecordingHandler, StateMachineHandler, VisualizationHandler, TagDetector, BasicCam, SIMBasicCam, SIMZEDCam, ZEDCam, and ObjectDetector.

◆ PooledLinearCode()

template<class T >

virtual T AutonomyThread< T >::PooledLinearCode ( )

privatepure virtual

Implemented in BasicCamera, ArucoGenerateTagsThreaded, PrimeCalculatorThread, RecordingHandler, StateMachineHandler, VisualizationHandler, TagDetector, BasicCam, SIMBasicCam, SIMZEDCam, ZEDCam, and ObjectDetector.

◆ RunThread()

template<class T >

void AutonomyThread< T >::RunThread ( std::atomic_bool & bStopThread )

inlineprivate

This method is ran in a separate thread. It is a middleware between the class member thread and the user code that handles graceful stopping of user code. This method is intentionally designed to not return anything.

Parameters

bStopThread - Atomic shared variable that signals the thread to stop iterating.

Author: ClayJay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2023-07-24

        {
            // Declare instance variables.
            std::chrono::_V2::system_clock::time_point tmStartTime;
 
            // Loop until stop flag is set.
            while (!bStopThread)
            {
                // Check if max IPS limit has been set.
                if (m_nMainThreadMaxIterationPerSecond > 0)
                {
                    // Get start execution time.
                    tmStartTime = std::chrono::high_resolution_clock::now();
                }
 
                // Call method containing user code.
                this->ThreadedContinuousCode();
 
                // Check if max IPS limit has been set.
                if (m_nMainThreadMaxIterationPerSecond > 0)
                {
                    // Get end execution time.
                    std::chrono::_V2::system_clock::time_point tmEndTime = std::chrono::high_resolution_clock::now();
                    // Get execution time of user code.
                    std::chrono::microseconds tmElapsedTime = std::chrono::duration_cast<std::chrono::microseconds>(tmEndTime - tmStartTime);
                    // Check if the elapsed time is slower than the max iterations per seconds.
                    if (tmElapsedTime.count() < (1.0 / m_nMainThreadMaxIterationPerSecond) * 1000000)
                    {
                        // Calculate the time to wait to stay under IPS cap.
                        int nSleepTime = ((1.0 / m_nMainThreadMaxIterationPerSecond) * 1000000) - tmElapsedTime.count();
                        // Make this thread sleep for the remaining time.
                        std::this_thread::sleep_for(std::chrono::microseconds(nSleepTime));
                    }
                }
 
                // Check if thread state needs to be updated.
                if (m_eThreadState != AutonomyThreadState::eRunning && m_eThreadState != AutonomyThreadState::eStopping)
                {
                    // Update thread state to running.
                    m_eThreadState = AutonomyThreadState::eRunning;
                    // Notify waiting start method that thread is now running.
                    m_cdThreadRunningCondition.notify_all();
                }
 
                // Call iteration per second tracking tick.
                m_IPS.Tick();
            }
 
            // Notify waiting start method that thread is now stopping.
            m_cdThreadRunningCondition.notify_all();
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GenerateUUIDV4()

template<class T >

std::string AutonomyThread< T >::GenerateUUIDV4 ( )

inlineprivate

Generates a random UUID v4 string. This is useful for generating unique IDs for files, threads, or any other objects that need to be uniquely identified.

Returns: std::string - A random UUID v4 string.

Author: clayjay3 (clayt.nosp@m.onra.nosp@m.ycowe.nosp@m.n@gm.nosp@m.ail.c.nosp@m.om)

Date: 2026-04-21

        {
            static std::random_device stdRandomDevice;
            static std::mt19937 stdGen(stdRandomDevice());
            static std::uniform_int_distribution<> stdDist1(0, 15);
            static std::uniform_int_distribution<> stdDist2(8, 11);
 
            std::stringstream stdStream;
            stdStream << std::hex;
            for (int nIter = 0; nIter < 8; nIter++)
            {
                stdStream << stdDist1(stdGen);
            }
            stdStream << "-";
            for (int nIter = 0; nIter < 4; nIter++)
            {
                stdStream << stdDist1(stdGen);
            }
            stdStream << "-4";
            for (int nIter = 0; nIter < 3; nIter++)
            {
                stdStream << stdDist1(stdGen);
            }
            stdStream << "-";
            stdStream << stdDist2(stdGen);
            for (int nIter = 0; nIter < 3; nIter++)
            {
                stdStream << stdDist1(stdGen);
            }
            stdStream << "-";
            for (int nIter = 0; nIter < 12; nIter++)
            {
                stdStream << stdDist1(stdGen);
            }
            return stdStream.str();
        }

Here is the caller graph for this function:

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

src/interfaces/AutonomyThread.hpp

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ AutonomyThreadState

◆ AutonomyThreadPriority

Constructor & Destructor Documentation

◆ AutonomyThread()

◆ ~AutonomyThread()

Member Function Documentation

◆ Start()

◆ RequestStop()

◆ Join()

◆ Joinable()

◆ GetThreadState()

◆ GetThreadUUID()

◆ GetIPS()

◆ SetMainThreadPriority()

◆ SetPoolThreadPriority()

◆ RunPool()

◆ RunDetachedPool()

◆ ParallelizeLoop()

◆ ClearPoolQueue()

◆ JoinPool()

◆ PoolJoinable()

◆ SetMainThreadIPSLimit()

◆ GetPoolNumOfThreads()

◆ GetPoolQueueLength()

◆ GetPoolResults()

◆ GetMainThreadMaxIPS()

◆ ThreadedContinuousCode()

◆ PooledLinearCode()

◆ RunThread()

◆ GenerateUUIDV4()