This class creates a thread for calculating N prime numbers. This is an example class demonstrating the use of the threading interface. More...

#include <PrimeNumbers.hpp>

Inheritance diagram for PrimeCalculatorThread:

[legend]

Collaboration diagram for PrimeCalculatorThread:

[legend]

Public Member Functions
void	SetPrimeCount (int nNum)
	Mutator for the Prime Count private member.

int	GetDesiredPrimeAmount ()
	Accessor for the Prime Counter private member.

std::vector< int >	GetPrimes ()
	Accessor for the Primes private member.

void	ClearPrimes ()
	Clears the prime results vector.

Public Member Functions inherited from AutonomyThread< void >
	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.

Private Member Functions
bool	IsPrime (int &nNum)
	Check if a number if prime.

void	CalculatePrimes (int &nCount)
	Calculate 'count' number of primes.

void	ThreadedContinuousCode () override
	This code will run in a separate thread. Main code goes here.

void	PooledLinearCode () override
	Any highly parallelizable code that can be used in the main thread goes here.

Private Attributes
std::vector< int >	m_vThreadPrimes

int	m_nCount = 10

int	m_nCurrentCount = 2

Additional Inherited Members
Public Types inherited from AutonomyThread< void >
enum	AutonomyThreadState

Protected Member Functions inherited from AutonomyThread< void >
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.

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< void >	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 inherited from AutonomyThread< void >
IPS	m_IPS

Detailed Description

This class creates a thread for calculating N prime numbers. This is an example class demonstrating the use of the threading interface.

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

Date: 2023-07-28

Member Function Documentation

◆ IsPrime()

bool PrimeCalculatorThread::IsPrime ( int & nNum )

inlineprivate

Check if a number if prime.

Parameters

num	- The number to check.

Returns: true - The number is prime.; false - The number is not prime.

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

Date: 2023-07-22

        {
            if (nNum <= 1)
            {
                return false;
            }
            for (int i = 2; i * i <= nNum; ++i)
            {
                if (nNum % i == 0)
                {
                    return false;
                }
            }
 
            return true;
        }

Here is the caller graph for this function:

◆ CalculatePrimes()

void PrimeCalculatorThread::CalculatePrimes ( int & nCount )

inlineprivate

Calculate 'count' number of primes.

Parameters

nCount - The number of primes to calculate.

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

Date: 2023-07-22

        {
            // Loop until we have the required amount of primes.
            if (int(m_vThreadPrimes.size()) < nCount)
            {
                // Check if our current number is a prime.
                if (IsPrime(m_nCurrentCount))
                {
                    m_vThreadPrimes.push_back(m_nCurrentCount);
                }
 
                // Increment counter.
                ++m_nCurrentCount;
            }
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ThreadedContinuousCode()

void PrimeCalculatorThread::ThreadedContinuousCode ( )

inlineoverrideprivatevirtual

This code will run in a separate thread. Main code goes here.

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

Date: 2023-07-22

Implements AutonomyThread< void >.

        {
            // Change this to calculate a different number of prime numbers.
            CalculatePrimes(m_nCount);
 
            // Check if we have reached the desired number of primes.
            if (int(this->GetPrimes().size()) >= this->GetDesiredPrimeAmount())
            {
                // Call thread stop.
                this->RequestStop();
            }
        }