CThreadPool Class Reference

#include <ThreadPool.h>

Inheritance diagram for CThreadPool:

Collaboration diagram for CThreadPool:


Classes
struct	_JobData
struct	_ThreadData
Public Types
typedef ThreadPoolProc	LPThreadPoolProc
typedef ThreadDWORDPoolProc	LPThreadDWORDPoolProc
typedef ThreadPoolDataProc	LPThreadPoolDataProc
typedef InitializePoolProc	LPInitializePoolProc
typedef VOID(*	ThreadPoolProc )(LPVOID pParam)
typedef DWORD(*	ThreadDWORDPoolProc )(LPVOID pParam)
typedef VOID(*	ThreadPoolDataProc )(LPVOID pParam, LPVOID pThreadData)
typedef BOOL(*	InitializePoolProc )(LPVOID &pParam, BOOL bLoading)
enum	_LogPriority { lpDebug, lpMessage, lpCritical, lpError }
typedef enum CErrorHandler::_LogPriority	LogPriority
Public Member Functions
void	Clear ()
void	SetExtraDataDrop (BOOL bDrop)
void	SetSleepInterval (DWORD dwSleepInterval)
BOOL	IsInitialized () const
int	GetRunningThreads () const
DWORD	GetMaxThreads () const
BOOL	IsFinished () const
int	GetWaitingJobs () const
BOOL	SubmitJob (LPThreadPoolProc pJobProc, LPVOID lpData)
BOOL	SubmitJob (LPThreadDWORDPoolProc pJobProc, LPVOID lpData)
BOOL	SubmitJob (LPThreadPoolDataProc pJobProc, LPVOID lpData)
	CThreadPool (unsigned long ulNumberOfThreads, unsigned long ulMaxJobsPending=THREAD_POOL_DEFAULT_JOBS, LPInitializePoolProc pInitializeProc=NULL, CGenericThread::ThreadPriority aPriority=CGenericThread::tpNormal)
virtual	~CThreadPool ()
void	SetLocalLog (CErrorLog *pLog)
Static Public Member Functions
static std::string	GetCurrentDateTime ()
static std::string	ErrorCodeToString (DWORD dwErrorCode)
static void	SetLog (CErrorLog *pLog)
Protected Member Functions
const std::string &	GetClassName () const
void	WriteMessage (const std::string &rMethod, const std::string &rMessage, LogPriority aPriority=lpMessage)
void	WriteMessage (const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData, LogPriority aPriority=lpMessage)
virtual void	ReportError (const std::string &rMethod) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData) const
virtual void	ReportError (const std::string &rMethod, int iErrorCode) const
virtual void	ReportError (const std::string &rMethod, const std::string &rMessage, int iErrorCode) const
virtual void	ReportErrorOS (const std::string &rMethod, const std::string &rMessage) const
void	SetName (const std::string &rName) const
Static Protected Member Functions
static void	WriteStaticMessage (const std::string &rClass, const std::string &rMethod, const std::string &rMessage, LogPriority aPriority=lpMessage)
static void	WriteStaticMessage (const std::string &rClass, const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData, LogPriority aPriority=lpMessage)
static void	ReportStaticError (const std::string &rClass, const std::string &rMethod)
static void	ReportStaticError (const std::string &rClass, const std::string &rMethod, const std::string &rMessage)
static void	ReportStaticError (const std::string &rClass, const std::string &rMethod, const std::string &rMessage, DWORD dwAdditionalData)

Detailed Description

Definition at line 62 of file ThreadPool.h.

Member Typedef Documentation

typedef BOOL(* CThreadPool::InitializePoolProc)(LPVOID &pParam, BOOL bLoading)

typedef enum CErrorHandler::_LogPriority CErrorHandler::LogPriority [inherited]

typedef InitializePoolProc CThreadPool::LPInitializePoolProc

Definition at line 81 of file ThreadPool.h.

typedef ThreadDWORDPoolProc CThreadPool::LPThreadDWORDPoolProc

Definition at line 71 of file ThreadPool.h.

typedef ThreadPoolDataProc CThreadPool::LPThreadPoolDataProc

Definition at line 76 of file ThreadPool.h.

typedef ThreadPoolProc CThreadPool::LPThreadPoolProc

Definition at line 67 of file ThreadPool.h.

typedef DWORD(* CThreadPool::ThreadDWORDPoolProc)(LPVOID pParam)

typedef VOID(* CThreadPool::ThreadPoolDataProc)(LPVOID pParam, LPVOID pThreadData)

typedef VOID(* CThreadPool::ThreadPoolProc)(LPVOID pParam)

Member Enumeration Documentation

enum CErrorHandler::_LogPriority [inherited]

Enumerator:

lpDebug
lpMessage
lpCritical
lpError

Definition at line 53 of file ErrorHandler.h.

00054     {
00055         lpDebug,
00056         lpMessage,
00057         lpCritical,
00058         lpError
00059     } LogPriority;

Constructor & Destructor Documentation

CThreadPool::CThreadPool	(	unsigned long	ulNumberOfThreads,
		unsigned long	ulMaxJobsPending = `THREAD_POOL_DEFAULT_JOBS`,
		LPInitializePoolProc	pInitializeProc = `NULL`,
		CGenericThread::ThreadPriority	aPriority = `CGenericThread::tpNormal`
	)

Definition at line 59 of file ThreadPool.cpp.

00062                                                                  : CErrorHandler(),
00063                                                                      m_ulThreadCount(ulNumberOfThreads),
00064                                                                      m_pSemaphore(NULL),
00065                                                                      m_ppThreads(NULL),
00066                                                                      m_pCSection(NULL),
00067                                                                      m_ulJobsCount(0),
00068                                                                      m_ppThreadData(NULL),
00069                                                                      m_iMaxJobsPending(ulMaxJobsPending),
00070                                                                      m_pCSectionCounter(NULL),
00071                                                                      m_iRunningThreads(0),
00072                                                                      m_bInitialized(FALSE),
00073                                                                      m_dwSleepInterval(1),
00074                                                                      m_bDrop(FALSE)
00075 {
00076     try
00077     {
00078         //Set our name
00079         SetName(CThreadPool_Class);
00080 
00081         //Create the semaphore
00082         m_pSemaphore=COSManager::CreateSemaphore(0,m_iMaxJobsPending);
00083 
00084         //Create the CS
00085         m_pCSection=COSManager::CreateCriticalSection();
00086         m_pCSectionCounter=COSManager::CreateCriticalSection();
00087 
00088         //Initialize the threads
00089         m_bInitialized=SpawnThreads(pInitializeProc,
00090                                     aPriority);
00091     }
00092     ERROR_HANDLER("CThreadPool")
00093 }

CThreadPool::~CThreadPool ( ) [virtual]

Definition at line 95 of file ThreadPool.cpp.

00096 {
00097     try
00098     {
00099         //Clear the threads
00100         ClearThreads();
00101 
00102         //Delete the semaphore
00103         delete m_pSemaphore;
00104         
00105         //Delete the CS
00106         delete m_pCSection;
00107         delete m_pCSectionCounter;
00108     }
00109     ERROR_HANDLER("~CThreadPool")
00110 }

Member Function Documentation

void CThreadPool::Clear ( )

Definition at line 538 of file ThreadPool.cpp.

00539 {
00540     try
00541     {
00542         CCriticalAutoRelease aRelease(m_pCSection);
00543 
00544         //Check we can have if
00545         if (!m_ulJobsCount)
00546             return;
00547 
00548         //Delete the data
00549         m_aJobList.clear();
00550         m_ulJobsCount=0;
00551     }
00552     ERROR_HANDLER("Clear")
00553 }

std::string CErrorHandler::ErrorCodeToString ( DWORD dwErrorCode ) [static, inherited]

Definition at line 122 of file ErrorHandler.cpp.

00123 {
00124     try
00125     {
00126         //Get the error string
00127         LPVOID lpMsgBuf;
00128         FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | 
00129                       FORMAT_MESSAGE_FROM_SYSTEM | 
00130                       FORMAT_MESSAGE_IGNORE_INSERTS,
00131                       NULL,
00132                       dwErrorCode,
00133                       MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
00134                       (LPTSTR) &lpMsgBuf,
00135                       0,
00136                       NULL);
00137 
00138         //Save it
00139         std::string sMessage;
00140         sMessage+=(char*)lpMsgBuf;
00141         
00142         //Release the buffer
00143         LocalFree(lpMsgBuf);
00144 
00145         //Done
00146         return sMessage;
00147     }
00148     catch (...)
00149     {
00150         return "Unknown";
00151     }
00152 }

const std::string & CErrorHandler::GetClassName ( ) const [protected, inherited]

Reimplemented in CSocketThreadManager.

Definition at line 516 of file ErrorHandler.cpp.

00517 {
00518     return m_sClassName;
00519 }

std::string CErrorHandler::GetCurrentDateTime ( ) [static, inherited]

Definition at line 521 of file ErrorHandler.cpp.

00522 {
00523     try
00524     {
00525         //Our string
00526         std::string sDate;
00527 
00528         //Our tmp buf
00529         char cTmp[128];
00530 
00531         //Get date
00532         _strdate(cTmp);
00533         sDate=cTmp;
00534         sDate+=' ';
00535 
00536         //Get time
00537         _strtime(cTmp);
00538         sDate+=cTmp;
00539 
00540         //Done
00541         return sDate;
00542     }
00543     ERROR_HANDLER_STATIC_RETURN(CErrorHandler_Class,"GetCurrentDateTime","")
00544 }

DWORD CThreadPool::GetMaxThreads ( ) const

Definition at line 513 of file ThreadPool.cpp.

00514 {
00515     return m_ulThreadCount;
00516 }

int CThreadPool::GetRunningThreads ( ) const

Definition at line 533 of file ThreadPool.cpp.

00534 {
00535     return m_iRunningThreads;
00536 }

int CThreadPool::GetWaitingJobs ( ) const

Definition at line 479 of file ThreadPool.cpp.

00480 {
00481     try
00482     {
00483         CCriticalAutoRelease aRelease(m_pCSection);
00484 
00485         //Save the number of jobs
00486         int iJobs;
00487         iJobs=m_ulJobsCount;
00488 
00489         //And return it
00490         return iJobs;
00491     }
00492     ERROR_HANDLER_RETURN("GetWaitingJobs",0)
00493 }

BOOL CThreadPool::IsFinished ( ) const

Definition at line 508 of file ThreadPool.cpp.

00509 {
00510     return m_ulJobsCount==0 && m_iRunningThreads==0;
00511 }

BOOL CThreadPool::IsInitialized ( ) const

Definition at line 518 of file ThreadPool.cpp.

00519 {
00520     return m_bInitialized;
00521 }

void CErrorHandler::ReportError	(	const std::string &	rMethod,
		const std::string &	rMessage,
		int	iErrorCode
	)			const `[protected, virtual, inherited]`

Definition at line 154 of file ErrorHandler.cpp.

00157 {
00158     if (!GetLog())
00159         return;
00160 
00161     try
00162     {
00163         //Get the log
00164         CErrorLog* pLog;
00165         pLog=GetLog();
00166 
00167         //Convert the error code
00168         char aTmp[11];
00169         sprintf(aTmp,"%d",iErrorCode);
00170 
00171         //Get the string for it
00172         std::string sError;
00173         sError=rMessage;
00174         sError+=", and Socket error: ";
00175         sError+=aTmp;
00176         sError+=", ";
00177         sError+=ErrorCodeToString(iErrorCode);
00178 
00179         //Report to the log
00180         pLog->ReportError(m_sClassName,
00181                           rMethod,
00182                           sError);
00183     }
00184     ERROR_UNKNOWN("ReportError")
00185 }

void CErrorHandler::ReportError	(	const std::string &	rMethod,
		int	iErrorCode
	)			const `[protected, virtual, inherited]`

Definition at line 187 of file ErrorHandler.cpp.

00189 {
00190     if (!GetLog())
00191         return;
00192 
00193     try
00194     {
00195         //Get the log
00196         CErrorLog* pLog;
00197         pLog=GetLog();
00198 
00199         //Convert the error code
00200         char aTmp[11];
00201         sprintf(aTmp,"%d",iErrorCode);
00202 
00203         //Get the string for it
00204         std::string sError;
00205         sError="Socket error: ";
00206         sError+=aTmp;
00207         sError+=", ";
00208         sError+=ErrorCodeToString(iErrorCode);
00209 
00210         //Report to the log
00211         pLog->ReportError(m_sClassName,
00212                           rMethod,
00213                           sError);
00214     }
00215     ERROR_UNKNOWN("ReportError")
00216 }

void CErrorHandler::ReportError	(	const std::string &	rMethod,
		const std::string &	rMessage,
		DWORD	dwAdditionalData
	)			const `[protected, virtual, inherited]`

Definition at line 275 of file ErrorHandler.cpp.

00278 {
00279     if (!GetLog())
00280         return;
00281 
00282     try
00283     {
00284         //Get the log
00285         CErrorLog* pLog;
00286         pLog=GetLog();
00287 
00288         //Convert the number
00289         char aTmp[11];
00290         ltoa(dwAdditionalData,aTmp,10);
00291 
00292         //Create the new message
00293         std::string sNewMessage(rMessage);
00294         sNewMessage+="Additional data: ";
00295         sNewMessage+=aTmp;
00296 
00297         //Report to the log
00298         pLog->ReportError(m_sClassName,
00299                           rMethod,
00300                           sNewMessage);
00301     }
00302     ERROR_UNKNOWN("ReportError")
00303 }

void CErrorHandler::ReportError	(	const std::string &	rMethod,
		const std::string &	rMessage
	)			const `[protected, virtual, inherited]`

Definition at line 218 of file ErrorHandler.cpp.

00220 {
00221     if (!GetLog())
00222         return;
00223 
00224     try
00225     {
00226         CErrorLog* pLog;
00227         pLog=GetLog();
00228 
00229         //Report to the log
00230         pLog->ReportError(m_sClassName,
00231                           rMethod,
00232                           rMessage);
00233     }
00234     ERROR_UNKNOWN("ReportError")
00235 }

void CErrorHandler::ReportError ( const std::string & rMethod ) const [protected, virtual, inherited]

Definition at line 311 of file ErrorHandler.cpp.

00312 {
00313     if (!GetLog())
00314         return;
00315 
00316     try
00317     {
00318 #ifdef WIN32
00319         //Get the last error
00320         DWORD dwLastError;
00321         dwLastError=GetLastError();
00322 
00323         //Report the error
00324         GetLog()->ReportError(m_sClassName,
00325                               rMethod,
00326                               ErrorCodeToString(dwLastError));
00327 
00328 #else
00329         GetLog()->ReportCatchError(m_sClassName,
00330                                    rMethod,
00331                                    "Unknown error!");
00332 #endif
00333     }
00334     ERROR_UNKNOWN("ReportError")
00335 }

void CErrorHandler::ReportErrorOS	(	const std::string &	rMethod,
		const std::string &	rMessage
	)			const `[protected, virtual, inherited]`

Definition at line 237 of file ErrorHandler.cpp.

00239 {
00240     if (!GetLog())
00241         return;
00242 
00243     try
00244     {
00245         //Get the last error
00246         DWORD dwLastError;
00247         dwLastError=GetLastError();
00248 
00249         //Format the message
00250         std::string sMessage;
00251         sMessage=rMessage;
00252         sMessage+=", with error code: ";
00253 
00254         //Convert the error code
00255         char aTmp[11];
00256         itoa(dwLastError,aTmp,10);
00257 
00258         //Add it again
00259         sMessage+=aTmp;
00260         sMessage+=" ";
00261         sMessage+=ErrorCodeToString(dwLastError);
00262         
00263         //Get the log
00264         CErrorLog* pLog;
00265         pLog=GetLog();
00266 
00267         //Report to the log
00268         pLog->ReportError(m_sClassName,
00269                           rMethod,
00270                           sMessage);
00271     }
00272     ERROR_UNKNOWN("ReportErrorOS")
00273 }

void CErrorHandler::ReportStaticError	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage,
		DWORD	dwAdditionalData
	)			`[static, protected, inherited]`

Definition at line 489 of file ErrorHandler.cpp.

00493 {
00494     if (!m_pLog)
00495         return;
00496 
00497     try
00498     {
00499         //Convert the number
00500         char aTmp[11];
00501         ltoa(dwAdditionalData,aTmp,10);
00502 
00503         //Create the new message
00504         std::string sNewMessage(rMessage);
00505         sNewMessage+="Additional data: ";
00506         sNewMessage+=aTmp;
00507 
00508         //Report to the log
00509         m_pLog->ReportError(rClass,
00510                             rMethod,
00511                             sNewMessage);
00512     }
00513     ERROR_UNKNOWN("ReportStaticError")
00514 }

void CErrorHandler::ReportStaticError	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage
	)			`[static, protected, inherited]`

Definition at line 472 of file ErrorHandler.cpp.

00475 {
00476     if (!m_pLog)
00477         return;
00478 
00479     try
00480     {
00481         //Report to the log
00482         m_pLog->ReportError(rClass,
00483                             rMethod,
00484                             rMessage);
00485     }
00486     ERROR_UNKNOWN("ReportStaticError")
00487 }

void CErrorHandler::ReportStaticError	(	const std::string &	rClass,
		const std::string &	rMethod
	)			`[static, protected, inherited]`

Definition at line 446 of file ErrorHandler.cpp.

00448 {
00449     if (!m_pLog)
00450         return;
00451 
00452     try
00453     {
00454 #ifdef WIN32
00455         //Get the last error
00456         DWORD dwLastError;
00457         dwLastError=GetLastError();
00458 
00459         //Report the error
00460         m_pLog->ReportError(rClass,
00461                             rMethod,
00462                             ErrorCodeToString(dwLastError));
00463 #else
00464         m_pLog->ReportError(rClass,
00465                             rMethod,
00466                             "Unknown error!");
00467 #endif
00468     }
00469     ERROR_UNKNOWN("ReportStaticError")
00470 }

void CThreadPool::SetExtraDataDrop ( BOOL bDrop )

Definition at line 528 of file ThreadPool.cpp.

00529 {
00530     m_bDrop=bDrop;
00531 }

void CErrorHandler::SetLocalLog ( CErrorLog * pLog ) [inherited]

Definition at line 441 of file ErrorHandler.cpp.

00442 {
00443     m_pLocalLog=pLog;
00444 }

void CErrorHandler::SetLog ( CErrorLog * pLog ) [static, inherited]

Definition at line 305 of file ErrorHandler.cpp.

00306 {
00307     //Save the new log
00308     m_pLog=pLog;
00309 }

void CErrorHandler::SetName ( const std::string & rName ) const [protected, inherited]

Definition at line 116 of file ErrorHandler.cpp.

00117 {
00118     //Save the class name
00119     m_sClassName=rName;
00120 }

void CThreadPool::SetSleepInterval ( DWORD dwSleepInterval )

Definition at line 523 of file ThreadPool.cpp.

00524 {
00525     m_dwSleepInterval=dwSleepInterval;
00526 }

BOOL CThreadPool::SubmitJob	(	LPThreadPoolDataProc	pJobProc,
		LPVOID	lpData
	)

Definition at line 211 of file ThreadPool.cpp.

00213 {
00214     try
00215     {
00216         return SubmitJob(NULL,
00217                          NULL,
00218                          pJobProc,
00219                          lpData);
00220     }
00221     ERROR_HANDLER_RETURN("SubmitJob",FALSE)
00222 }

BOOL CThreadPool::SubmitJob	(	LPThreadDWORDPoolProc	pJobProc,
		LPVOID	lpData
	)

Definition at line 198 of file ThreadPool.cpp.

00200 {
00201     try
00202     {
00203         return SubmitJob(NULL,
00204                          pJobProc,
00205                          NULL,
00206                          lpData);
00207     }
00208     ERROR_HANDLER_RETURN("SubmitJob",FALSE)
00209 }

BOOL CThreadPool::SubmitJob	(	LPThreadPoolProc	pJobProc,
		LPVOID	lpData
	)

Definition at line 185 of file ThreadPool.cpp.

00187 {
00188     try
00189     {
00190         return SubmitJob(pJobProc,
00191                          NULL,
00192                          NULL,
00193                          lpData);
00194     }
00195     ERROR_HANDLER_RETURN("SubmitJob",FALSE)
00196 }

void CErrorHandler::WriteMessage	(	const std::string &	rMethod,
		const std::string &	rMessage,
		DWORD	dwAdditionalData,
		LogPriority	aPriority = `lpMessage`
	)			`[protected, inherited]`

Definition at line 355 of file ErrorHandler.cpp.

00359 {
00360     if (!GetLog())
00361         return;
00362 
00363     try
00364     {
00365         //Convert the number
00366         char aTmp[11];
00367         ltoa(dwAdditionalData,aTmp,10);
00368 
00369         //Create the new message
00370         std::string sNewMessage(rMessage);
00371         sNewMessage+="Additional data: ";
00372         sNewMessage+=aTmp;
00373 
00374         //Delegate the call
00375         GetLog()->WriteMessage(m_sClassName,
00376                                rMethod,
00377                                sNewMessage,
00378                                aPriority);
00379     }
00380     ERROR_UNKNOWN("WriteMessage")
00381 }

void CErrorHandler::WriteMessage	(	const std::string &	rMethod,
		const std::string &	rMessage,
		LogPriority	aPriority = `lpMessage`
	)			`[protected, inherited]`

Definition at line 337 of file ErrorHandler.cpp.

00340 {
00341     if (!GetLog())
00342         return;
00343 
00344     try
00345     {
00346         //Delegate the call
00347         GetLog()->WriteMessage(m_sClassName,
00348                                rMethod,
00349                                rMessage,
00350                                aPriority);
00351     }
00352     ERROR_UNKNOWN("WriteMessage")
00353 }

void CErrorHandler::WriteStaticMessage	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage,
		DWORD	dwAdditionalData,
		LogPriority	aPriority = `lpMessage`
	)			`[static, protected, inherited]`

Definition at line 403 of file ErrorHandler.cpp.

00408 {
00409     if (!m_pLog)
00410         return;
00411 
00412     try
00413     {
00414         //Convert the number
00415         char aTmp[11];
00416         ltoa(dwAdditionalData,aTmp,10);
00417 
00418         //Create the new message
00419         std::string sNewMessage(rMessage);
00420         sNewMessage+="Additional data: ";
00421         sNewMessage+=aTmp;
00422 
00423         //Delegate the call
00424         m_pLog->WriteMessage(rClass,
00425                              rMethod,
00426                              sNewMessage,
00427                              aPriority);
00428     }
00429     ERROR_UNKNOWN("WriteStaticMessage")
00430 }

void CErrorHandler::WriteStaticMessage	(	const std::string &	rClass,
		const std::string &	rMethod,
		const std::string &	rMessage,
		LogPriority	aPriority = `lpMessage`
	)			`[static, protected, inherited]`

Definition at line 383 of file ErrorHandler.cpp.

00388 {
00389     if (!m_pLog)
00390         return;
00391 
00392     try
00393     {
00394         //Delegate the call
00395         m_pLog->WriteMessage(rClass,
00396                              rMethod,
00397                              rMessage,
00398                              aPriority);
00399     }
00400     ERROR_UNKNOWN("WriteStaticMessage")
00401 }

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

Retail products

Documentation

CThreadPool Class Reference

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation