AutonomyThread< T > Class Template Reference

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

#include <AutonomyThread.hpp>

Collaboration diagram for AutonomyThread< T >:

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

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.
IPS &	GetIPS ()
	Accessor for the Frame I P S private member.

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.

Private Attributes
BS::thread_pool	m_thMainThread = BS::thread_pool(1)
BS::thread_pool	m_thPool = BS::thread_pool(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

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
        };

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;
        }

~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]() { 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

{ return m_eThreadState; }

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

{ return m_IPS; }

Here is the caller 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 i = 0; i < nNumTasksToQueue; ++i)
            {
                // 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 i = 0; i < nNumTasksToQueue; ++i)
            {
                // 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.
            BS::thread_pool m_thLoopPool = BS::thread_pool(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

{ 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

{ 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

{ 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

{ return m_thPool.get_tasks_queued(); }

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, 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, 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:

---

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

• src/interfaces/AutonomyThread.hpp