Fixup of LLAtomic and LLThreadSafeRefCount

indra/llaudio/llaudiodecodemgr.cpp

@@ -168,19 +168,13 @@ long vfs_tell (void *datasource)
 	return file->tell();
 }
 
-LLVorbisDecodeState::LLVorbisDecodeState(const LLUUID &uuid, const std::string &out_filename)
-{
-	mDone = FALSE;
-	mValid = FALSE;
-	mBytesRead = -1;
-	mUUID = uuid;
-	mInFilep = NULL;
-	mCurrentSection = 0;
+LLVorbisDecodeState::LLVorbisDecodeState(const LLUUID &uuid, const std::string &out_filename) :
+	mValid(FALSE), mDone(FALSE), mBytesRead(-1), mUUID(uuid),
 #if !defined(USE_WAV_VFILE)
-	mOutFilename = out_filename;
-	mFileHandle = LLLFSThread::nullHandle();
+	mOutFilename(out_filename), mFileHandle(LLLFSThread::nullHandle()),
 #endif
-	// No default value for mVF, it's an ogg structure?
+	mInFilep(NULL), mCurrentSection(0)
+{
 }
 
 LLVorbisDecodeState::~LLVorbisDecodeState()

indra/llcommon/CMakeLists.txt

@@ -121,6 +121,7 @@ set(llcommon_HEADER_FILES
     llaprpool.h
     llassettype.h
     llassoclist.h
+    llatomic.h
     llavatarconstants.h
     llbase32.h
     llbase64.h

indra/llcommon/llapr.h

@@ -91,27 +91,6 @@ protected:
 	apr_thread_mutex_t* mMutex;
 };
 
-template <typename Type> class LLAtomic32
-{
-public:
-	LLAtomic32<Type>() {};
-	LLAtomic32<Type>(Type x) {apr_atomic_set32(&mData, apr_uint32_t(x)); };
-	~LLAtomic32<Type>() {};
-
-	operator const Type() { apr_uint32_t data = apr_atomic_read32(&mData); return Type(data); }
-	Type operator =(const Type& x) { apr_atomic_set32(&mData, apr_uint32_t(x)); return Type(mData); }
-	void operator -=(Type x) { apr_atomic_sub32(&mData, apr_uint32_t(x)); }
-	void operator +=(Type x) { apr_atomic_add32(&mData, apr_uint32_t(x)); }
-	Type operator ++(int) { return apr_atomic_inc32(&mData); } // Type++
-	Type operator --(int) { return apr_atomic_dec32(&mData); } // Type--
-	
-private:
-	apr_uint32_t mData;
-};
-
-typedef LLAtomic32<U32> LLAtomicU32;
-typedef LLAtomic32<S32> LLAtomicS32;
-
 // File IO convenience functions.
 // Returns NULL if the file fails to open, sets *sizep to file size if not NULL
 // abbreviated flags

indra/llcommon/llatomic.h

@@ -0,0 +1,61 @@
+/** 
+ * @file llatomic.h
+ * @brief Definition of LLAtomic
+ *
+ * $LicenseInfo:firstyear=2004&license=viewergpl$
+ * 
+ * Copyright (c) 2004-2009, Linden Research, Inc.
+ * Copyright (c) 2012, Aleric Inglewood
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLATOMIC_H
+#define LL_LLATOMIC_H
+
+#include "apr_atomic.h"
+
+template <typename Type> class LLAtomic32
+{
+public:
+	LLAtomic32(void) { }
+	LLAtomic32(LLAtomic32 const& atom) { apr_uint32_t data = apr_atomic_read32(const_cast<apr_uint32_t*>(&atom.mData)); apr_atomic_set32(&mData, data); }
+	LLAtomic32(Type x) { apr_atomic_set32(&mData, static_cast<apr_uint32_t>(x)); }
+	LLAtomic32& operator=(LLAtomic32 const& atom) { apr_uint32_t data = apr_atomic_read32(const_cast<apr_uint32_t*>(&atom.mData)); apr_atomic_set32(&mData, data); return *this; }
+
+	operator Type() const { apr_uint32_t data = apr_atomic_read32(const_cast<apr_uint32_t*>(&mData)); return static_cast<Type>(data); }
+	void operator=(Type x) { apr_atomic_set32(&mData, static_cast<apr_uint32_t>(x)); }
+	void operator-=(Type x) { apr_atomic_sub32(&mData, static_cast<apr_uint32_t>(x)); }
+	void operator+=(Type x) { apr_atomic_add32(&mData, static_cast<apr_uint32_t>(x)); }
+	Type operator++(int) { return apr_atomic_inc32(&mData); } // Type++
+	bool operator--() { return apr_atomic_dec32(&mData); } // Returns (--Type != 0)
+	
+private:
+	apr_uint32_t mData;
+};
+
+typedef LLAtomic32<U32> LLAtomicU32;
+typedef LLAtomic32<S32> LLAtomicS32;
+
+#endif

indra/llcommon/llcommon.cpp

@@ -39,7 +39,6 @@ void LLCommon::initClass()
 {
 	LLMemory::initClass();
 	LLTimer::initClass();
-	LLThreadSafeRefCount::initThreadSafeRefCount();
 // 	LLWorkerThread::initClass();
 // 	LLFrameCallbackManager::initClass();
 }
@@ -49,7 +48,6 @@ void LLCommon::cleanupClass()
 {
 // 	LLFrameCallbackManager::cleanupClass();
 // 	LLWorkerThread::cleanupClass();
-	LLThreadSafeRefCount::cleanupThreadSafeRefCount();
 	LLTimer::cleanupClass();
 	LLMemory::cleanupClass();
 }

indra/llcommon/llthread.cpp

@@ -178,7 +178,7 @@ void LLThread::shutdown()
 		}
 		mAPRThreadp = NULL;
 	}
-	sCount--;
+	--sCount;
 	delete mRunCondition;
 	mRunCondition = 0;
 }
@@ -444,28 +444,6 @@ void LLMutexBase::unlock()
 	apr_thread_mutex_unlock(mAPRMutexp);
 }
 
-//----------------------------------------------------------------------------
-
-//static
-LLMutex* LLThreadSafeRefCount::sMutex = 0;
-
-//static
-void LLThreadSafeRefCount::initThreadSafeRefCount()
-{
-	if (!sMutex)
-	{
-		sMutex = new LLMutex;
-	}
-}
-
-//static
-void LLThreadSafeRefCount::cleanupThreadSafeRefCount()
-{
-	delete sMutex;
-	sMutex = NULL;
-}
-	
-
 //----------------------------------------------------------------------------
 
 LLThreadSafeRefCount::LLThreadSafeRefCount() :

indra/llcommon/llthread.h

@@ -38,6 +38,7 @@
 #include "llmemory.h"
 #include "apr_thread_cond.h"
 #include "llaprpool.h"
+#include "llatomic.h"
 
 #ifdef SHOW_ASSERT
 extern LL_COMMON_API bool is_main_thread(void);
@@ -400,13 +401,6 @@ void LLThread::unlockData()
 
 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
@@ -419,31 +413,20 @@ public:
 	
 	void ref()
 	{
-		if (sMutex) sMutex->lock();
 		mRef++; 
-		if (sMutex) sMutex->unlock();
 	} 
 
-	S32 unref()
+	void unref()
 	{
-		llassert(mRef >= 1);
-		if (sMutex) sMutex->lock();
-		S32 res = --mRef;
-		if (sMutex) sMutex->unlock();
-		if (0 == res) 
-		{
-			delete this; 
-			return 0;
-		}
-		return res;
-	}	
+		if (!--mRef) delete this;
+	}
 	S32 getNumRefs() const
 	{
 		return mRef;
 	}
 
 private: 
-	S32	mRef; 
+	LLAtomicS32	mRef; 
 };
 
 //============================================================================