initial commit

dng/dng_mutex.cpp

@@ -0,0 +1,394 @@
+/*****************************************************************************/
+// Copyright 2006-2008 Adobe Systems Incorporated
+// All Rights Reserved.
+//
+// NOTICE:  Adobe permits you to use, modify, and distribute this file in
+// accordance with the terms of the Adobe license agreement accompanying it.
+/*****************************************************************************/
+
+/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_mutex.cpp#3 $ */ 
+/* $DateTime: 2012/09/05 12:31:51 $ */
+/* $Change: 847652 $ */
+/* $Author: tknoll $ */
+
+#include "dng_mutex.h"
+
+#include "dng_assertions.h"
+#include "dng_exceptions.h"
+
+#include <stdlib.h>
+
+/*****************************************************************************/
+
+#if qDNGThreadSafe
+
+namespace
+	{
+
+	class InnermostMutexHolder
+		{
+		
+		private:
+
+			pthread_key_t fInnermostMutexKey;
+
+		public:
+
+			InnermostMutexHolder ()
+			
+				:	fInnermostMutexKey ()
+				
+				{
+
+				int result = pthread_key_create (&fInnermostMutexKey, NULL);
+
+				DNG_ASSERT (result == 0, "pthread_key_create failed.");
+
+				if (result != 0)
+					ThrowProgramError ();
+
+				}
+
+			~InnermostMutexHolder ()
+				{
+				
+				pthread_key_delete (fInnermostMutexKey);
+				
+				}
+
+			void SetInnermostMutex (dng_mutex *mutex)
+				{
+
+				int result;
+
+				result = pthread_setspecific (fInnermostMutexKey, (void *)mutex);
+
+				DNG_ASSERT (result == 0, "pthread_setspecific failed.");
+
+				#if 0		// Hard failure here was causing crash on quit.
+				
+				if (result != 0)
+					ThrowProgramError ();
+					
+				#endif
+
+				}
+
+			dng_mutex *GetInnermostMutex ()
+				{
+
+				void *result = pthread_getspecific (fInnermostMutexKey);
+
+				return reinterpret_cast<dng_mutex *> (result);
+
+				}
+
+		};
+
+	InnermostMutexHolder gInnermostMutexHolder;
+	
+	}
+
+#endif
+
+/*****************************************************************************/
+
+dng_mutex::dng_mutex (const char *mutexName, uint32 mutexLevel)
+
+	#if qDNGThreadSafe
+	
+	:	fPthreadMutex		()
+	,	fMutexLevel			(mutexLevel)
+	,	fRecursiveLockCount (0)
+	,	fPrevHeldMutex		(NULL)
+	,	fMutexName			(mutexName)
+	
+	#endif
+	
+	{
+	
+	#if qDNGThreadSafe
+
+	if (pthread_mutex_init (&fPthreadMutex, NULL) != 0)
+		{
+		ThrowMemoryFull ();
+		}
+	
+	#endif
+	
+	}
+
+/*****************************************************************************/
+
+dng_mutex::~dng_mutex ()
+	{
+	
+	#if qDNGThreadSafe
+
+	pthread_mutex_destroy (&fPthreadMutex);
+
+	#endif
+	
+	}
+
+/*****************************************************************************/
+
+void dng_mutex::Lock ()
+	{
+	
+	#if qDNGThreadSafe
+
+	dng_mutex *innermostMutex = gInnermostMutexHolder.GetInnermostMutex ();
+
+	if (innermostMutex != NULL)
+		{
+
+		if (innermostMutex == this)
+			{
+
+			fRecursiveLockCount++;
+
+			return;
+
+			}
+
+		bool lockOrderPreserved = fMutexLevel > innermostMutex->fMutexLevel /* ||
+								  (fMutexLevel == innermostMutex->fMutexLevel && innermostMutex < this) */;
+
+		if (!lockOrderPreserved)
+			{
+			
+			DNG_REPORT ("Lock ordering violation.");
+			
+			#if qDNGDebug
+			
+			dng_show_message_f ("This mutex: %s v Innermost mutex: %s",
+								this->MutexName (),
+								innermostMutex->MutexName ());
+			
+			#endif
+
+			}
+
+		}
+
+	pthread_mutex_lock (&fPthreadMutex);
+
+	fPrevHeldMutex = innermostMutex;
+
+	gInnermostMutexHolder.SetInnermostMutex (this);
+
+	#endif
+	
+	}
+
+/*****************************************************************************/
+
+void dng_mutex::Unlock ()
+	{
+	
+	#if qDNGThreadSafe
+	
+	DNG_ASSERT (gInnermostMutexHolder.GetInnermostMutex () == this, "Mutexes unlocked out of order!!!");
+
+	if (fRecursiveLockCount > 0)
+		{
+
+		fRecursiveLockCount--;
+
+		return;
+
+		}
+
+	gInnermostMutexHolder.SetInnermostMutex (fPrevHeldMutex);
+
+	fPrevHeldMutex = NULL;
+
+	pthread_mutex_unlock (&fPthreadMutex);
+	
+	#endif
+	
+	}
+
+/*****************************************************************************/
+
+const char *dng_mutex::MutexName () const
+	{
+	
+	#if qDNGThreadSafe
+	
+	if (fMutexName)
+		return fMutexName;
+	
+	#endif
+	
+	return "< unknown >";
+	
+	}
+
+/*****************************************************************************/
+
+dng_lock_mutex::dng_lock_mutex (dng_mutex *mutex)
+
+	:	fMutex (mutex)
+	
+	{
+	
+	if (fMutex)
+		fMutex->Lock ();
+		
+	}
+
+/*****************************************************************************/
+
+dng_lock_mutex::~dng_lock_mutex ()
+	{
+	
+	if (fMutex)
+		fMutex->Unlock ();
+		
+	}
+
+/*****************************************************************************/
+
+dng_unlock_mutex::dng_unlock_mutex (dng_mutex *mutex)
+
+	:	fMutex (mutex)
+	
+	{
+	
+	if (fMutex)
+		fMutex->Unlock ();
+		
+	}
+
+/*****************************************************************************/
+
+dng_unlock_mutex::~dng_unlock_mutex ()
+	{
+	
+	if (fMutex)
+		fMutex->Lock ();
+		
+	}
+
+/*****************************************************************************/
+
+#if qDNGThreadSafe
+
+/*****************************************************************************/
+
+dng_condition::dng_condition ()
+
+	:	fPthreadCondition ()
+
+	{
+
+	int result;
+
+	result = pthread_cond_init (&fPthreadCondition, NULL);
+
+	DNG_ASSERT (result == 0, "pthread_cond_init failed.");
+
+	if (result != 0)
+		{
+		ThrowProgramError ();
+		}
+
+	}
+
+/*****************************************************************************/
+
+dng_condition::~dng_condition ()
+	{
+	
+	pthread_cond_destroy (&fPthreadCondition);
+	
+	}
+
+/*****************************************************************************/
+
+bool dng_condition::Wait (dng_mutex &mutex, double timeoutSecs)
+	{
+
+	bool timedOut = false;
+
+	dng_mutex *innermostMutex = gInnermostMutexHolder.GetInnermostMutex ();
+
+	DNG_ASSERT (innermostMutex == &mutex, "Attempt to wait on non-innermost mutex.");
+
+	innermostMutex = mutex.fPrevHeldMutex;
+
+	gInnermostMutexHolder.SetInnermostMutex (innermostMutex);
+
+	mutex.fPrevHeldMutex = NULL;
+
+	if (timeoutSecs < 0)
+		{
+		
+		pthread_cond_wait (&fPthreadCondition, &mutex.fPthreadMutex);
+		
+		}
+		
+	else
+		{
+		
+		struct timespec now;
+
+		dng_pthread_now (&now);
+
+		timeoutSecs += now.tv_sec;
+		timeoutSecs += now.tv_nsec / 1000000000.0;
+
+		now.tv_sec  = (long) timeoutSecs;
+		now.tv_nsec = (long) ((timeoutSecs - now.tv_sec) * 1000000000);
+
+		timedOut = (pthread_cond_timedwait (&fPthreadCondition, &mutex.fPthreadMutex, &now) == ETIMEDOUT);
+		
+		}
+
+	mutex.fPrevHeldMutex = innermostMutex;
+
+	gInnermostMutexHolder.SetInnermostMutex (&mutex);
+
+	return !timedOut;
+
+	}
+
+/*****************************************************************************/
+
+void dng_condition::Signal ()
+	{
+
+	int result;
+
+	result = pthread_cond_signal (&fPthreadCondition);
+
+	DNG_ASSERT (result == 0, "pthread_cond_signal failed.");
+
+	if (result != 0)
+		ThrowProgramError ();
+
+	}
+
+/*****************************************************************************/
+
+void dng_condition::Broadcast ()
+	{
+
+	int result;
+
+	result = pthread_cond_broadcast (&fPthreadCondition);
+
+	DNG_ASSERT (result == 0, "pthread_cond_broadcast failed.");
+
+	if (result != 0)
+		ThrowProgramError ();
+
+	}
+
+/*****************************************************************************/
+
+#endif // qDNGThreadSafe
+
+/*****************************************************************************/