//-------------------------------------------------------------------------
// Desc:	Cross platform toolkit for threads.
// Tabs:	3
//
//		Copyright (c) 2000-2006 Novell, Inc. All Rights Reserved.
//
//		This program is free software; you can redistribute it and/or
//		modify it under the terms of version 2 of the GNU General Public
//		License as published by the Free Software Foundation.
//
//		This program is distributed in the hope that it will be useful,
//		but WITHOUT ANY WARRANTY; without even the implied warranty of
//		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//		GNU General Public License for more details.
//
//		You should have received a copy of the GNU General Public License
//		along with this program; if not, contact Novell, Inc.
//
//		To contact Novell about this file by physical or electronic mail,
//		you may find current contact information at www.novell.com
//
// $Id: ftkthrd.cpp 12329 2006-01-20 17:49:30 -0700 (Fri, 20 Jan 2006) ahodgkinson $
//-------------------------------------------------------------------------

#include "flaimsys.h"

#if defined( FLM_UNIX)
	#include <signal.h>
#endif

#ifdef FLM_NLM
	static void * threadStub(
		void *	pvUnused,
		void *	pvThread);
#elif defined( FLM_WIN)
	static unsigned __stdcall threadStub(
		void *	pvThread);
#elif defined( FLM_UNIX)
	extern "C"
	{
		static void * threadStub(
			void *	pvThread);
	}
#endif

/****************************************************************************
Desc:		Add a Reference to this object.
****************************************************************************/
FLMUINT F_Thread::AddRef(
	FLMBOOL		bMutexLocked)
{
	FLMUINT		uiRefCnt;

	if( !bMutexLocked)
	{
		f_mutexLock( m_hMutex);
	}

	uiRefCnt = ++m_ui32RefCnt;

	if( !bMutexLocked)
	{
		f_mutexUnlock( m_hMutex);
	}

	return( uiRefCnt);
}

/****************************************************************************
Desc:		Removes a reference to this object.
****************************************************************************/
FLMUINT F_Thread::Release( 
	FLMBOOL		bMutexLocked)
{
	FLMUINT		uiRefCnt;

	if( !bMutexLocked && m_hMutex != F_MUTEX_NULL)
	{
		f_mutexLock( m_hMutex);
	}

	flmAssert( m_ui32RefCnt > 0);
	uiRefCnt = --m_ui32RefCnt;

	if( !bMutexLocked && m_hMutex != F_MUTEX_NULL)
	{
		f_mutexUnlock( m_hMutex);
	}

	if( !uiRefCnt)
	{
		delete this;
	}

	return( uiRefCnt);
}

/****************************************************************************
Desc:    Performs various setup work and starts a new thread
****************************************************************************/
RCODE F_Thread::startThread(
	F_THREAD_FUNC	fnThread, 
	const char *	pszThreadName,
	FLMUINT			uiThreadGroup,
	FLMUINT			uiAppId,
	void *			pvParm1,
	void *			pvParm2,
	FLMUINT        uiStackSize)
{
	RCODE				rc = FERR_OK;
	FLMBOOL			bManagerMutexLocked = FALSE;
#ifdef FLM_NLM
	void *			hThread = NULL;
#endif
#ifdef FLM_WIN
	unsigned			uiThreadId;
#endif
#if defined( FLM_UNIX)
	#if defined( _POSIX_THREADS)
		pthread_attr_t	thread_attr;
		pthread_t		uiThreadId;
	#else
		threadid_p		uiThreadId;
	#endif
#endif

	flmAssert( fnThread != NULL && m_fnThread == NULL);

	m_fnThread = fnThread;
	m_pvParm1 = pvParm1;
	m_pvParm2 = pvParm2;

	// Initialize the thread's mutex

	if( RC_BAD( rc = f_mutexCreate( &m_hMutex)))
	{
		goto Exit;
	}

	// Set the stack size

	m_uiStackSize = (uiStackSize < F_THREAD_MIN_STACK_SIZE)
							? F_THREAD_MIN_STACK_SIZE
							: uiStackSize;

	// Set the thread name

	if( pszThreadName && *pszThreadName)
	{
		FLMUINT		uiNameLen = f_strlen( pszThreadName) + 1;

		if( RC_BAD( rc = f_alloc( uiNameLen, &m_pszThreadName)))
		{
			goto Exit;
		}

		f_memcpy( m_pszThreadName, pszThreadName, uiNameLen);
	}

	// Set the thread group ID and the application-specified thread ID

	m_uiThreadGroup = uiThreadGroup;
	m_uiAppId = uiAppId;

	// Set the thread's state to "running" -- if we fail to
	// start the thread, this will be set back to false when
	// the cleanupThread() method is called below.  We set this
	// to TRUE here so that the stopThread() method won't get
	// stuck in an infinite loop if the thread was never started.

	m_bRunning = TRUE;

	// Lock the thread manager's mutex.

	f_mutexLock( gv_FlmSysData.pThreadMgr->m_hMutex);
	bManagerMutexLocked = TRUE;

	// Increment the active thread count

	gv_FlmSysData.pThreadMgr->m_uiNumThreads++;

	// Link the thread into the manager's list.  We can't link threads in order
	// by thread ID at this point, because we don't know what the new thread's
	// ID will be.

	if( gv_FlmSysData.pThreadMgr->m_pThreadList)
	{
		gv_FlmSysData.pThreadMgr->m_pThreadList->m_pPrev = this;
	}

	m_pNext = gv_FlmSysData.pThreadMgr->m_pThreadList;
	gv_FlmSysData.pThreadMgr->m_pThreadList = this;

	// Increment the reference count of the thread object now
	// that it is linked into the thread manager's list.

	AddRef();
	
	// Start the thread

#ifdef FLM_WIN
	if( _beginthreadex( 
		NULL, (unsigned int)m_uiStackSize, threadStub,
		(void *)this, 0, &uiThreadId) == 0) // 0 indicates a failure
	{
		rc = RC_SET( FERR_THREAD_ERR);
		goto Exit;
	}
	m_uiThreadId = (FLMUINT)uiThreadId;
#elif defined( FLM_NLM)
	if( (hThread = kCreateThread( 
		(BYTE *)((m_pszThreadName)
			? (BYTE *)m_pszThreadName 
			: (BYTE *)"NDSDB"),
		threadStub, NULL, (LONG)m_uiStackSize,
		(void *)this)) == NULL)
	{
		rc = RC_SET( FERR_THREAD_ERR);
		goto Exit;
	}
	m_uiThreadId = (FLMUINT)hThread;

	if( kSetThreadLoadHandle( hThread, (LONG)f_getNLMHandle()) != 0)
	{
		(void)kDestroyThread( hThread);
		rc = RC_SET( FERR_THREAD_ERR);
		goto Exit;
	}
			
   if( kScheduleThread( hThread) != 0)
	{
		(void)kDestroyThread( hThread);
		rc = RC_SET( FERR_THREAD_ERR);
		goto Exit;
	}
#elif defined( FLM_UNIX)
	#ifdef  _POSIX_THREADS
		pthread_attr_init( &thread_attr);
		pthread_attr_setdetachstate( &thread_attr, PTHREAD_CREATE_DETACHED);
		
		if (pthread_create( &uiThreadId, &thread_attr,
				threadStub, this) != 0)
		{
			rc = RC_SET( FERR_THREAD_ERR);
			goto Exit;
		}
	#else
		m_uiStackSize = f_max( m_uiStackSize, thr_minstack());
		m_uiStackSize = f_max( m_uiStackSize, thr_min_stack());

		if( thr_create( (void*)NULL, (size_t)uiStackSize,
			threadStub, this, (long)0, &uiThreadId) != 0)
		{
			rc = RC_SET( FERR_THREAD_ERR);
			goto Exit;
		}
	#endif

		m_uiThreadId = (FLMUINT)uiThreadId;

	#ifdef _POSIX_THREADS
		pthread_attr_destroy( &thread_attr);     
	#endif
#endif

	// Code is not designed to handle a thread ID of 0

	flmAssert( m_uiThreadId != 0);

	// Unlock the thread manager's mutex.

	f_mutexUnlock( gv_FlmSysData.pThreadMgr->m_hMutex);
	bManagerMutexLocked = FALSE;

Exit:

	if( RC_BAD( rc))
	{
		// Unlink the thread from the manager's list.  This call
		// won't do anything if the thread was not linked above.

		gv_FlmSysData.pThreadMgr->unlinkThread( this, bManagerMutexLocked);

		// Reset the thread object back to its initial state

		cleanupThread();
	}

	if( bManagerMutexLocked)
	{
		f_mutexUnlock( gv_FlmSysData.pThreadMgr->m_hMutex);
	}

	return( rc);
}

/****************************************************************************
Desc:    Stop a running thread
****************************************************************************/
void F_Thread::stopThread( void)
{
	// Set the shutdown flag and wait for the thread's
	// status to be something other than "running"

	m_bShutdown = TRUE;
	while( m_bRunning)
	{
		f_sleep( 10);
	}

	// Reset the shutdown flag in case this object is re-used.

	m_bShutdown = FALSE;
}

/****************************************************************************
Desc:    Begins a new thread of execution and calls the passed function.
			Performs generic thread init and cleanup functions.
****************************************************************************/
#ifdef FLM_NLM
void * threadStub(
	void *	pvUnused,
	void *	pvThread)
#elif defined( FLM_WIN)
unsigned __stdcall threadStub(
	void *	pvThread)
#elif defined( FLM_UNIX)
void * threadStub(
	void *	pvThread)
#endif
{
	F_Thread *		pThread = (F_Thread *)pvThread;

#ifdef FLM_NLM
	F_UNREFERENCED_PARM( pvUnused);
#endif

#ifdef FLM_UNIX
	// Block all signals (main thread will handle all signals)

	sigset_t mask;
	sigfillset(&mask);
	pthread_sigmask(SIG_SETMASK, &mask, 0);
#endif

	// Lock the manager's mutex

	gv_FlmSysData.pThreadMgr->lockMutex();

	// At this point, the thread ID must match.

	flmAssert( pThread->m_uiThreadId == f_threadId());

	// Set the start time

	f_timeGetSeconds( &pThread->m_uiStartTime);

	// Unlock the manager's mutex

	gv_FlmSysData.pThreadMgr->unlockMutex();

	// Call the thread's function

	pThread->m_exitRc = pThread->m_fnThread( pThread);

	// Add a temporary reference to the thread object so
	// it doesn't go away when we unlink it from the
	// manager

	pThread->AddRef();

	// Unlink the thread from the thread manager.

	gv_FlmSysData.pThreadMgr->unlinkThread( pThread, FALSE);

	// Set the running flag to FALSE

	pThread->m_bRunning = FALSE;

	// Release the temporary reference to the thread.  Once the
	// reference is release, pThread must not be accessed because
	// the object may have gone away.

	pThread->Release();
	pThread = NULL;

	// Terminate the thread

#if defined( FLM_WIN)
	_endthreadex( 0);
	return( 0);
#elif defined( FLM_NLM)
	kExitThread( NULL);
#endif

#if defined( FLM_NLM) || defined( FLM_UNIX)
	return( NULL);
#endif
}

/****************************************************************************
Desc:    Frees any resources allocated to the thread and resets member
			variables to their initial state
****************************************************************************/
void F_Thread::cleanupThread( void)
{
	flmAssert( !m_pPrev && !m_pNext);
	if( m_hMutex != F_MUTEX_NULL)
	{
		f_mutexDestroy( &m_hMutex);
	}

	if( m_pszThreadName)
	{
		f_free( &m_pszThreadName);
	}

	if( m_pszThreadStatus)
	{
		f_free( &m_pszThreadStatus);
	}

	m_uiStatusBufLen = 0;
	m_bShutdown = FALSE;
	m_fnThread = NULL;
	m_bRunning = FALSE;
	m_uiStackSize = 0;
	m_pvParm1 = NULL;
	m_pvParm2 = NULL;
	m_uiThreadId = 0;
	m_uiThreadGroup = FLM_DEFAULT_THREAD_GROUP;
	m_uiAppId = 0;
	m_uiStartTime = 0;
	m_exitRc = FERR_OK;
}

/****************************************************************************
Desc:    Set the thread's status
****************************************************************************/
void F_Thread::_setThreadStatus(
	const char *	pszStatus)
{
	FLMUINT		uiStatusLen = f_strlen( pszStatus) + 1;

	if( m_uiStatusBufLen < uiStatusLen)
	{
		FLMUINT		uiAllocSize = uiStatusLen < 128 ? 128 : uiStatusLen;

		if( m_pszThreadStatus != NULL)
		{
			f_free( &m_pszThreadStatus);
		}
		m_uiStatusBufLen = 0;

		if( RC_BAD( f_alloc( uiAllocSize, &m_pszThreadStatus)))
		{
			m_pszThreadStatus = NULL;
			goto Exit;
		}

		m_uiStatusBufLen = uiAllocSize;
	}

	f_mutexLock( m_hMutex);
	f_memcpy( m_pszThreadStatus, pszStatus, uiStatusLen);
	f_mutexUnlock( m_hMutex);

Exit:

	return;
}

/****************************************************************************
Desc:    Set the thread's status
****************************************************************************/
void F_Thread::setThreadStatus(
	const char *	pszFormat, ...)
{
	char			pucBuffer[ 128];
	f_va_list	args;

	f_va_start( args, pszFormat);
	f_vsprintf( pucBuffer, pszFormat, &args);
	f_va_end( args);

	_setThreadStatus( pucBuffer);
}

/****************************************************************************
Desc:    Set the thread's status to a generic string
****************************************************************************/
void F_Thread::setThreadStatus(
	eFlmThreadStatus	eGenericStatus)
{
	const char *		pszStatus = NULL;

	switch( eGenericStatus)
	{
		case FLM_THREAD_STATUS_INITIALIZING:
			pszStatus = "Initializing";
			break;

		case FLM_THREAD_STATUS_RUNNING:
			pszStatus = "Running";
			break;

		case FLM_THREAD_STATUS_SLEEPING:
			pszStatus = "Sleeping";
			break;

		case FLM_THREAD_STATUS_TERMINATING:
			pszStatus = "Terminating";
			break;

		case FLM_THREAD_STATUS_STARTING_TRANS:
			pszStatus = "Starting transaction";
			break;

		case FLM_THREAD_STATUS_COMMITTING_TRANS:
			pszStatus = "Committing transaction";
			break;

		case FLM_THREAD_STATUS_ABORTING_TRANS:
			pszStatus = "Aborting transaction";
			break;

		case FLM_THREAD_STATUS_UNKNOWN:
		default:
			pszStatus = "Unknown";
			break;
	}

	if( pszStatus)
	{
		setThreadStatus( pszStatus);
	}
}

/****************************************************************************
Desc:		Allocates resources needed by the thread manager
****************************************************************************/
RCODE F_ThreadMgr::setupThreadMgr( void)
{
	RCODE		rc = FERR_OK;	

	flmAssert( m_hMutex == F_MUTEX_NULL);

	if( RC_BAD( rc = f_mutexCreate( &m_hMutex)))
	{
		goto Exit;
	}

Exit:

	return( rc);
}

/****************************************************************************
Desc:		Removes a thread from the thread manager's list
Notes:	This routine assumes that the manager's mutex is already locked.
****************************************************************************/
void F_ThreadMgr::unlinkThread(
	F_Thread *		pThread,
	FLMBOOL			bMutexIsLocked)
{
	// Lock the thread manager's mutex

	if( !bMutexIsLocked)
	{
		f_mutexLock( m_hMutex);
	}

	// If the thread isn't linked into the list,
	// don't do anything

	if( !pThread->m_pPrev && !pThread->m_pNext &&
		m_pThreadList != pThread)
	{
		goto Exit;
	}

	// Decrement the active thread count

	flmAssert( m_uiNumThreads);
	m_uiNumThreads--;

	if( pThread->m_pPrev)
	{
		pThread->m_pPrev->m_pNext = pThread->m_pNext;
	}
	else
	{
		m_pThreadList = pThread->m_pNext;
	}

	if( pThread->m_pNext)
	{
		pThread->m_pNext->m_pPrev = pThread->m_pPrev;
	}

	pThread->m_pNext = NULL;
	pThread->m_pPrev = NULL;

	// Release the thread object

	pThread->Release();

Exit:

	if( !bMutexIsLocked)
	{
		f_mutexUnlock( m_hMutex);
	}
}

/****************************************************************************
Desc:		Signals all threads in a thread group to shut down and waits
			for them to terminate.
****************************************************************************/
void F_ThreadMgr::shutdownThreadGroup(
	FLMUINT		uiThreadGroup)
{
	F_Thread *			pThread;
	FLMUINT				uiCount;

	for( ;;)
	{
		f_mutexLock( m_hMutex);

		uiCount = 0;
		pThread = m_pThreadList;
		while( pThread)
		{
			if( pThread->m_uiThreadGroup == uiThreadGroup)
			{
				pThread->setShutdownFlag();
				uiCount++;
			}
			pThread = pThread->m_pNext;
		}

		f_mutexUnlock( m_hMutex);

		if( !uiCount)
		{
			break;
		}

		// The threads will automatically unlink themselves from
		// the manager before they terminate.  Just sleep for
		// a few milliseconds and look through the list again to
		// verify that there are no more threads in the group.

		f_sleep( 200);
	}
}

/****************************************************************************
Desc:		Signals a thread to shut down.
****************************************************************************/
void F_ThreadMgr::setThreadShutdownFlag(
	FLMUINT			uiThreadId)
{
	F_Thread *			pThread;

	flmAssert( uiThreadId != 0);

	f_mutexLock( m_hMutex);
	pThread = m_pThreadList;
	while( pThread)
	{
		if( pThread->m_uiThreadId == uiThreadId)
		{
			pThread->setShutdownFlag();
			break;
		}
		pThread = pThread->m_pNext;
	}

	f_mutexUnlock( m_hMutex);
}

/****************************************************************************
Desc:		Allocates an array of F_THREAD_INFO structures and populates them
			with information about the threads being managed by this object.
****************************************************************************/
RCODE F_ThreadMgr::getThreadInfo(
	POOL *					pPool,
	F_THREAD_INFO **		ppThreadInfo,
	FLMUINT *				puiNumThreads)
{
	RCODE					rc = FERR_OK;
	FLMUINT				uiOffset;
	FLMUINT				uiLoop;
	FLMUINT				uiSubLoop;
	FLMUINT				uiLen;
	FLMBOOL				bMutexLocked = FALSE;
	F_THREAD_INFO *	pThreadInfo = NULL;
	F_THREAD_INFO		tmpThreadInfo;
	F_Thread *			pCurThread;
	void *				pvMark = GedPoolMark( pPool);

	*ppThreadInfo = NULL;
	*puiNumThreads = 0;

	f_mutexLock( m_hMutex);
	bMutexLocked = TRUE;

	if( m_uiNumThreads == 0)
	{
		goto Exit;
	}

	if( (pThreadInfo = (F_THREAD_INFO *)GedPoolCalloc( pPool, 
		sizeof( F_THREAD_INFO) * m_uiNumThreads)) == NULL)
	{
		rc = RC_SET( FERR_MEM);
		goto Exit;
	}

	uiOffset = 0;
	pCurThread = m_pThreadList;
	while( pCurThread)
	{
		flmAssert( uiOffset < m_uiNumThreads);
		f_mutexLock( pCurThread->m_hMutex);

		pThreadInfo[ uiOffset].uiThreadId = pCurThread->m_uiThreadId;
		pThreadInfo[ uiOffset].uiThreadGroup = pCurThread->m_uiThreadGroup;
		pThreadInfo[ uiOffset].uiAppId = pCurThread->m_uiAppId;
		pThreadInfo[ uiOffset].uiStartTime = pCurThread->m_uiStartTime;

		if( pCurThread->m_pszThreadName)
		{
			uiLen = f_strlen( pCurThread->m_pszThreadName) + 1;

			if( ( pThreadInfo[ uiOffset].pszThreadName = 
				(char *)GedPoolCalloc( pPool, uiLen)) != NULL)
			{
				f_memcpy( pThreadInfo[ uiOffset].pszThreadName,
					pCurThread->m_pszThreadName, uiLen);
			}
		}

		if( pCurThread->m_pszThreadStatus)
		{
			uiLen = f_strlen( pCurThread->m_pszThreadStatus) + 1;

			if( ( pThreadInfo[ uiOffset].pszThreadStatus = 
				(char *)GedPoolCalloc( pPool, uiLen)) != NULL)
			{
				f_memcpy( pThreadInfo[ uiOffset].pszThreadStatus,
					pCurThread->m_pszThreadStatus, uiLen);
			}
		}

		f_mutexUnlock( pCurThread->m_hMutex);
		uiOffset++;
		pCurThread = pCurThread->m_pNext;
	}

	flmAssert( uiOffset == m_uiNumThreads);
	*puiNumThreads = m_uiNumThreads;

	f_mutexUnlock( m_hMutex);
	bMutexLocked = FALSE;

	// Sort the list by thread ID

	for( uiLoop = 0; uiLoop < *puiNumThreads; uiLoop++)
	{
		for( uiSubLoop = uiLoop + 1; uiSubLoop < *puiNumThreads; uiSubLoop++)
		{
			if( pThreadInfo[ uiLoop].uiThreadId > 
				pThreadInfo[ uiSubLoop].uiThreadId)
			{
				f_memcpy( &tmpThreadInfo, 
					&pThreadInfo[ uiLoop], sizeof( F_THREAD_INFO));
				f_memcpy( &pThreadInfo[ uiLoop], 
					&pThreadInfo[ uiSubLoop], sizeof( F_THREAD_INFO));
				f_memcpy( &pThreadInfo[ uiSubLoop], 
					&tmpThreadInfo, sizeof( F_THREAD_INFO));
			}
		}
	}

	*ppThreadInfo = pThreadInfo;

Exit:

	if( RC_BAD( rc))
	{
		GedPoolReset( pPool, pvMark);
	}

	if( bMutexLocked)
	{
		f_mutexUnlock( m_hMutex);
	}

	return( rc);
}

/****************************************************************************
Desc:		Finds a thread based on user-specified identifiers
****************************************************************************/
RCODE F_ThreadMgr::findThread(
	F_Thread **		ppThread,
	FLMUINT			uiThreadGroup,
	FLMUINT			uiAppId,
	FLMBOOL			bOkToFindMe)
{
	RCODE					rc = FERR_OK;
	FLMBOOL				bMutexLocked = FALSE;
	F_Thread *			pCurThread;

	*ppThread = NULL;

	f_mutexLock( m_hMutex);
	bMutexLocked = TRUE;

	if( m_uiNumThreads == 0)
	{
		rc = RC_SET( FERR_NOT_FOUND);
		goto Exit;
	}

	pCurThread = m_pThreadList;
	while( pCurThread)
	{
		f_mutexLock( pCurThread->m_hMutex);

		if( pCurThread->m_uiThreadGroup == uiThreadGroup &&
			pCurThread->m_uiAppId == uiAppId)
		{
			if( bOkToFindMe || 
				(!bOkToFindMe && pCurThread->m_uiThreadId != f_threadId()))
			{
				// Found a match.

				pCurThread->AddRef( TRUE);
				*ppThread = pCurThread;
				f_mutexUnlock( pCurThread->m_hMutex);
				goto Exit;
			}
		}
	
		f_mutexUnlock( pCurThread->m_hMutex);
		pCurThread = pCurThread->m_pNext;
	}

	rc = RC_SET( FERR_NOT_FOUND);

Exit:

	if( bMutexLocked)
	{
		f_mutexUnlock( m_hMutex);
	}

	return( rc);
}

/****************************************************************************
Desc:		Finds a thread based on user-specified identifiers
****************************************************************************/
RCODE F_ThreadMgr::getNextGroupThread(
	F_Thread **		ppThread,
	FLMUINT			uiThreadGroup,
	FLMUINT *		puiThreadId)
{
	RCODE				rc = FERR_OK;
	FLMBOOL			bMutexLocked = FALSE;
	F_Thread *		pCurThread;
	F_Thread *		pFoundThread = NULL;

	f_mutexLock( m_hMutex);
	bMutexLocked = TRUE;

	if( m_uiNumThreads == 0)
	{
		rc = RC_SET( FERR_NOT_FOUND);
		goto Exit;
	}

	pCurThread = m_pThreadList;
	while( pCurThread)
	{
		if( pCurThread->m_uiThreadGroup == uiThreadGroup &&
			pCurThread->m_uiThreadId > *puiThreadId)
		{
			// The threads are not kept in order by thread ID in the
			// manager's list.  So, we need to make sure we get the
			// thread with the next ID beyond the ID passed into the
			// routine.

			if( !pFoundThread || 
				pCurThread->m_uiThreadId < pFoundThread->m_uiThreadId)
			{
				pFoundThread = pCurThread;
			}
		}
	
		pCurThread = pCurThread->m_pNext;
	}

	if( !pFoundThread)
	{
		rc = RC_SET( FERR_NOT_FOUND);
		goto Exit;
	}

	pFoundThread->AddRef();
	*ppThread = pFoundThread;
	*puiThreadId = pFoundThread->m_uiThreadId;

Exit:

	if( RC_BAD( rc))
	{
		*ppThread = NULL;
		*puiThreadId = 0xFFFFFFFF;
	}

	if( bMutexLocked)
	{
		f_mutexUnlock( m_hMutex);
	}

	return( rc);
}

/****************************************************************************
Desc:		Returns a count of the number of threads in a specified group
****************************************************************************/
FLMUINT F_ThreadMgr::getThreadGroupCount(
	FLMUINT			uiThreadGroup)
{
	F_Thread *		pThread;
	FLMUINT			uiCount;

	f_mutexLock( m_hMutex);

	uiCount = 0;
	pThread = m_pThreadList;
	while( pThread)
	{
		if( pThread->m_uiThreadGroup == uiThreadGroup)
		{
			uiCount++;
		}
		pThread = pThread->m_pNext;
	}

	f_mutexUnlock( m_hMutex);
	return( uiCount);
}

/****************************************************************************
Desc:    Allocate a thread object and start the thread
****************************************************************************/
RCODE f_threadCreate(
	F_Thread **			ppThread,
	F_THREAD_FUNC		fnThread,
	const char *		pszThreadName,
	FLMUINT				uiThreadGroup,
	FLMUINT				uiAppId,
	void *				pvParm1,
	void *				pvParm2,
	FLMUINT				uiStackSize)
{
	RCODE				rc = FERR_OK;
	F_Thread *		pThread = NULL;

	if( ppThread)
	{
		*ppThread = NULL;
	}

	if( (pThread = f_new F_Thread) == NULL)
	{
		rc = RC_SET( FERR_MEM);
		goto Exit;
	}

	if( RC_BAD( rc = pThread->startThread(
		fnThread, pszThreadName, uiThreadGroup, uiAppId, 
		pvParm1, pvParm2, uiStackSize)))
	{
		goto Exit;
	}

	if( ppThread)
	{
		*ppThread = pThread;

		// Set pThread to NULL so that the object won't be released
		// below.  The application has indicated (by passing in a
		// non-NULL ppThread) that it wants to keep a reference to
		// the thread.

		pThread = NULL;
	}

Exit:

	if( pThread)
	{
		pThread->Release();
	}
	
	return( rc);
}

/****************************************************************************
Desc:		Deletes a thread object and sets the passed-in pointer to NULL
Notes:	Should not be used on threads that were started with the
			auto-destroy flag set to TRUE
****************************************************************************/
void f_threadDestroy(
	F_Thread **		ppThread)
{
	// Shutdown the thread

	if( *ppThread != NULL)
	{
		(*ppThread)->stopThread();
		(*ppThread)->Release();
		*ppThread = NULL;
	}
}

/****************************************************************************
Desc:		Destructor
****************************************************************************/
F_ThreadMgr::~F_ThreadMgr()
{
	F_Thread *		pTmpThread;

	if( m_hMutex != F_MUTEX_NULL)
	{
		f_mutexLock( m_hMutex);
		pTmpThread = m_pThreadList;
		while( pTmpThread)
		{
			pTmpThread->setShutdownFlag();
			pTmpThread = pTmpThread->m_pNext;
		}

		while( m_pThreadList)
		{
			f_mutexUnlock( m_hMutex);
			f_sleep( 50);
			f_mutexLock( m_hMutex);
		}
		f_mutexUnlock( m_hMutex);
		f_mutexDestroy( &m_hMutex);
	}
}