SH-3406 WIP convert fast timers to lltrace system

fixes to merge

6 files changed, 29 insertions, 284 deletions

diff --git a/indra/llcommon/llmemory.h b/indra/llcommon/llmemory.h
index 3744e68956..e725bdd9fa 100644
--- a/indra/llcommon/llmemory.h
+++ b/indra/llcommon/llmemory.h
@@ -26,7 +26,7 @@
 #ifndef LLMEMORY_H
 #define LLMEMORY_H
 
-#include "llmemtype.h"
+#include "linden_common.h"
 
 class LLMutex ;
 
diff --git a/indra/llcommon/llmutex.cpp b/indra/llcommon/llmutex.cpp
index 2ce14b3a2e..e6beb9e680 100644
--- a/indra/llcommon/llmutex.cpp
+++ b/indra/llcommon/llmutex.cpp
@@ -86,7 +86,7 @@ void LLMutex::lock()
 #if LL_DARWIN
 	mLockingThread = LLThread::currentID();
 #else
-	mLockingThread = LLThread::sThreadIndex;
+	mLockingThread = LLThread::sThreadID;
 #endif
 }
 
@@ -129,7 +129,7 @@ bool LLMutex::isSelfLocked()
 #if LL_DARWIN
 	return mLockingThread == LLThread::currentID();
 #else
-	return mLockingThread == LLThread::sThreadIndex;
+	return mLockingThread == LLThread::sThreadID;
 #endif
 }
 
@@ -182,48 +182,3 @@ void LLCondition::broadcast()
 
 
 //============================================================================
-
-//----------------------------------------------------------------------------
-
-//static
-LLMutex* LLThreadSafeRefCount::sMutex = 0;
-
-//static
-void LLThreadSafeRefCount::initThreadSafeRefCount()
-{
-	if (!sMutex)
-	{
-		sMutex = new LLMutex(0);
-	}
-}
-
-//static
-void LLThreadSafeRefCount::cleanupThreadSafeRefCount()
-{
-	delete sMutex;
-	sMutex = NULL;
-}
-
-
-//----------------------------------------------------------------------------
-
-LLThreadSafeRefCount::LLThreadSafeRefCount() :
-mRef(0)
-{
-}
-
-LLThreadSafeRefCount::~LLThreadSafeRefCount()
-{ 
-	if (mRef != 0)
-	{
-		llerrs << "deleting non-zero reference" << llendl;
-	}
-}
-
-//============================================================================
-
-LLResponder::~LLResponder()
-{
-}
-
-//============================================================================
diff --git a/indra/llcommon/llmutex.h b/indra/llcommon/llmutex.h
index bd0a59b577..cbde4c47a9 100644
--- a/indra/llcommon/llmutex.h
+++ b/indra/llcommon/llmutex.h
@@ -98,71 +98,4 @@ private:
 	LLMutex* mMutex;
 };
 
-
-//============================================================================
-
-// see llmemory.h for LLPointer<> definition
-
-class LL_COMMON_API LLThreadSafeRefCount
-{
-public:
-	static void initThreadSafeRefCount(); // creates sMutex
-	static void cleanupThreadSafeRefCount(); // destroys sMutex
-
-private:
-	static LLMutex* sMutex;
-
-private:
-	LLThreadSafeRefCount(const LLThreadSafeRefCount&); // not implemented
-	LLThreadSafeRefCount&operator=(const LLThreadSafeRefCount&); // not implemented
-
-protected:
-	virtual ~LLThreadSafeRefCount(); // use unref()
-
-public:
-	LLThreadSafeRefCount();
-
-	void ref()
-	{
-		if (sMutex) sMutex->lock();
-		mRef++; 
-		if (sMutex) sMutex->unlock();
-	} 
-
-	S32 unref()
-	{
-		llassert(mRef >= 1);
-		if (sMutex) sMutex->lock();
-		S32 res = --mRef;
-		if (sMutex) sMutex->unlock();
-		if (0 == res) 
-		{
-			delete this; 
-			return 0;
-		}
-		return res;
-	}	
-	S32 getNumRefs() const
-	{
-		return mRef;
-	}
-
-private: 
-	S32	mRef; 
-};
-
-
-//============================================================================
-
-// Simple responder for self destructing callbacks
-// Pure virtual class
-class LL_COMMON_API LLResponder : public LLThreadSafeRefCount
-{
-protected:
-	virtual ~LLResponder();
-public:
-	virtual void completed(bool success) = 0;
-};
-
-
 #endif // LL_LLTHREAD_H
diff --git a/indra/llcommon/llthread.cpp b/indra/llcommon/llthread.cpp
index 1c86eb4f06..8ce739bf23 100644
--- a/indra/llcommon/llthread.cpp
+++ b/indra/llcommon/llthread.cpp
@@ -62,7 +62,7 @@
 #if LL_DARWIN
 // statically allocated thread local storage not supported in Darwin executable formats
 #elif LL_WINDOWS
-U32 __declspec(thread) LLThread::sThreadIndex = 0;
+U32 __declspec(thread) LLThread::sThreadID = 0;
 #elif LL_LINUX
 U32 __thread LLThread::sThreadID = 0;
 #endif 
@@ -96,7 +96,7 @@ void *APR_THREAD_FUNC LLThread::staticRun(apr_thread_t *apr_threadp, void *datap
 	LLTrace::ThreadRecorder* thread_recorder = new LLTrace::SlaveThreadRecorder();
 
 #if !LL_DARWIN
-	sThreadIndex = threadp->mID;
+	sThreadID = threadp->mID;
 #endif
 
 	// Run the user supplied function
@@ -327,155 +327,6 @@ void LLThread::wakeLocked()
 
 //============================================================================
 
-LLMutex::LLMutex(apr_pool_t *poolp) :
-	mAPRMutexp(NULL), mCount(0), mLockingThread(NO_THREAD)
-{
-	//if (poolp)
-	//{
-	//	mIsLocalPool = FALSE;
-	//	mAPRPoolp = poolp;
-	//}
-	//else
-	{
-		mIsLocalPool = TRUE;
-		apr_pool_create(&mAPRPoolp, NULL); // Create a subpool for this thread
-	}
-	apr_thread_mutex_create(&mAPRMutexp, APR_THREAD_MUTEX_UNNESTED, mAPRPoolp);
-}
-
-
-LLMutex::~LLMutex()
-{
-#if MUTEX_DEBUG
-	//bad assertion, the subclass LLSignal might be "locked", and that's OK
-	//llassert_always(!isLocked()); // better not be locked!
-#endif
-	apr_thread_mutex_destroy(mAPRMutexp);
-	mAPRMutexp = NULL;
-	if (mIsLocalPool)
-	{
-		apr_pool_destroy(mAPRPoolp);
-	}
-}
-
-
-void LLMutex::lock()
-{
-	if(isSelfLocked())
-	{ //redundant lock
-		mCount++;
-		return;
-	}
-	
-	apr_thread_mutex_lock(mAPRMutexp);
-	
-#if MUTEX_DEBUG
-	// Have to have the lock before we can access the debug info
-	U32 id = LLThread::currentID();
-	if (mIsLocked[id] != FALSE)
-		llerrs << "Already locked in Thread: " << id << llendl;
-	mIsLocked[id] = TRUE;
-#endif
-
-#if LL_DARWIN
-	mLockingThread = LLThread::currentID();
-#else
-	mLockingThread = sThreadID;
-#endif
-}
-
-void LLMutex::unlock()
-{
-	if (mCount > 0)
-	{ //not the root unlock
-		mCount--;
-		return;
-	}
-	
-#if MUTEX_DEBUG
-	// Access the debug info while we have the lock
-	U32 id = LLThread::currentID();
-	if (mIsLocked[id] != TRUE)
-		llerrs << "Not locked in Thread: " << id << llendl;	
-	mIsLocked[id] = FALSE;
-#endif
-
-	mLockingThread = NO_THREAD;
-	apr_thread_mutex_unlock(mAPRMutexp);
-}
-
-bool LLMutex::isLocked()
-{
-	apr_status_t status = apr_thread_mutex_trylock(mAPRMutexp);
-	if (APR_STATUS_IS_EBUSY(status))
-	{
-		return true;
-	}
-	else
-	{
-		apr_thread_mutex_unlock(mAPRMutexp);
-		return false;
-	}
-}
-
-bool LLMutex::isSelfLocked()
-{
-#if LL_DARWIN
-	return mLockingThread == LLThread::currentID();
-#else
-	return mLockingThread == sThreadID;
-#endif
-}
-
-U32 LLMutex::lockingThread() const
-{
-	return mLockingThread;
-}
-
-//============================================================================
-
-LLCondition::LLCondition(apr_pool_t *poolp) :
-	LLMutex(poolp)
-{
-	// base class (LLMutex) has already ensured that mAPRPoolp is set up.
-
-	apr_thread_cond_create(&mAPRCondp, mAPRPoolp);
-}
-
-
-LLCondition::~LLCondition()
-{
-	apr_thread_cond_destroy(mAPRCondp);
-	mAPRCondp = NULL;
-}
-
-
-void LLCondition::wait()
-{
-	if (!isLocked())
-	{ //mAPRMutexp MUST be locked before calling apr_thread_cond_wait
-		apr_thread_mutex_lock(mAPRMutexp);
-#if MUTEX_DEBUG
-		// avoid asserts on destruction in non-release builds
-		U32 id = LLThread::currentID();
-		mIsLocked[id] = TRUE;
-#endif
-	}
-	apr_thread_cond_wait(mAPRCondp, mAPRMutexp);
-}
-
-void LLCondition::signal()
-{
-	apr_thread_cond_signal(mAPRCondp);
-}
-
-void LLCondition::broadcast()
-{
-	apr_thread_cond_broadcast(mAPRCondp);
-}
-
-//============================================================================
-
 //----------------------------------------------------------------------------
 
 //static
diff --git a/indra/llcommon/llthread.h b/indra/llcommon/llthread.h
index 94b6b6d682..75222c83f9 100644
--- a/indra/llcommon/llthread.h
+++ b/indra/llcommon/llthread.h
@@ -42,7 +42,7 @@ private:
 #if LL_DARWIN
 	// statically allocated thread local storage not supported in Darwin executable formats
 #elif LL_WINDOWS
-	static U32 __declspec(thread) LLThread::sThreadIndex;
+	static U32 __declspec(thread) LLThread::sThreadID;
 #elif LL_LINUX
 	static U32 __thread LLThread::sThreadID ;
 #endif
diff --git a/indra/llcommon/llunit.h b/indra/llcommon/llunit.h
index 1fe492fdce..53570779fc 100644
--- a/indra/llcommon/llunit.h
+++ b/indra/llcommon/llunit.h
@@ -109,9 +109,9 @@ struct LLUnit
 		return mValue;
 	}
 
-	template<typename NEW_UNIT_TYPE> LLUnit<NEW_UNIT_TYPE, STORAGE_TYPE> as()
+	template<typename NEW_UNIT_TYPE, typename NEW_STORAGE_TYPE> LLUnit<NEW_UNIT_TYPE, NEW_STORAGE_TYPE> as()
 	{
-		return LLUnit<NEW_UNIT_TYPE, STORAGE_TYPE>(*this);
+		return LLUnit<NEW_UNIT_TYPE, NEW_STORAGE_TYPE>(*this);
 	}
 
 	void operator += (storage_t value)
@@ -332,21 +332,27 @@ struct HighestPrecisionType<LLUnit<UNIT_TYPE, STORAGE_TYPE> >
 	typedef typename HighestPrecisionType<STORAGE_TYPE>::type_t type_t;
 };
 
-#define LL_DECLARE_DERIVED_UNIT(base_unit_name, unit_name, conversion_factor)                                                                                   \
-struct unit_name                                                                                                                                                \
-{                                                                                                                                                               \
-	typedef base_unit_name base_unit_t;                                                                                                                         \
-};                                                                                                                                                              \
-template<typename STORAGE_TYPE>                                                                                                                                 \
-struct ConversionFactor<unit_name, base_unit_name, STORAGE_TYPE>                                                                                                \
-{                                                                                                                                                               \
-	static typename HighestPrecisionType<STORAGE_TYPE>::type_t get() { return typename HighestPrecisionType<STORAGE_TYPE>::type_t(conversion_factor); }         \
-};                                                                                                                                                              \
-	                                                                                                                                                            \
-template<typename STORAGE_TYPE>                                                                                                                                 \
-struct ConversionFactor<base_unit_name, unit_name, STORAGE_TYPE>						                                                                        \
-{                                                                                                                                                               \
-	static typename HighestPrecisionType<STORAGE_TYPE>::type_t get() { return typename HighestPrecisionType<STORAGE_TYPE>::type_t(1.0 / (conversion_factor)); } \
+#define LL_DECLARE_DERIVED_UNIT(base_unit_name, unit_name, conversion_factor)                   \
+struct unit_name                                                                                \
+{                                                                                               \
+	typedef base_unit_name base_unit_t;                                                         \
+};                                                                                              \
+template<typename STORAGE_TYPE>                                                                 \
+struct ConversionFactor<unit_name, base_unit_name, STORAGE_TYPE>                                \
+{                                                                                               \
+	static typename HighestPrecisionType<STORAGE_TYPE>::type_t get()                            \
+	{                                                                                           \
+		return typename HighestPrecisionType<STORAGE_TYPE>::type_t(conversion_factor);          \
+	}                                                                                           \
+};                                                                                              \
+	                                                                                            \
+template<typename STORAGE_TYPE>                                                                 \
+struct ConversionFactor<base_unit_name, unit_name, STORAGE_TYPE>						        \
+{                                                                                               \
+	static typename HighestPrecisionType<STORAGE_TYPE>::type_t get()                            \
+	{                                                                                           \
+		return typename HighestPrecisionType<STORAGE_TYPE>::type_t(1.0 / (conversion_factor));  \
+	}                                                                                           \
 }
 
 struct Bytes { typedef Bytes base_unit_t; };