Second Life viewer sources 1.13.2.12

1 files changed, 183 insertions, 0 deletions

diff --git a/linden/indra/llcommon/llthread.h b/linden/indra/llcommon/llthread.h
new file mode 100644
index 0000000..2a13d72
--- /dev/null
+++ b/linden/indra/llcommon/llthread.h
@@ -0,0 +1,183 @@
+/** 
+ * @file llthread.h
+ * @brief Base classes for thread, mutex and condition handling.
+ *
+ * Copyright (c) 2004-2007, Linden Research, Inc.
+ * 
+ * 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://secondlife.com/developers/opensource/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://secondlife.com/developers/opensource/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.
+ */
+
+#ifndef LL_LLTHREAD_H
+#define LL_LLTHREAD_H
+
+#include "llapr.h"
+#include "llapp.h"
+
+#include "apr-1/apr_thread_cond.h"
+
+class LLThread;
+class LLMutex;
+class LLCondition;
+
+class LLThread
+{
+public:
+        typedef enum e_thread_status
+        {
+                STOPPED = 0,    // The thread is not running.  Not started, or has exited its run function
+                RUNNING = 1,    // The thread is currently running
+                QUITTING= 2     // Someone wants this thread to quit
+        } EThreadStatus;
+
+        LLThread(const std::string& name, apr_pool_t *poolp = NULL);
+        virtual ~LLThread(); // Warning!  You almost NEVER want to destroy a thread unless it's in the STOPPED state.
+                
+        static void yield(); // Static because it can be called by the main thread, which doesn't have an LLThread data structure.
+
+
+        bool isQuitting() const;
+        bool isStopped() const;
+        
+        // PAUSE / RESUME functionality. See source code for important usage notes.
+public:
+        // Called from MAIN THREAD.
+        void pause();
+        void unpause();
+        bool isPaused() { return mPaused ? true : false; }
+        
+        // Cause the thread to wake up and check its condition
+        void wake();
+
+        // Same as above, but to be used when the condition is already locked.
+        void wakeLocked();
+
+        // Called from run() (CHILD THREAD). Pause the thread if requested until unpaused.
+        void checkPause();
+
+        // this kicks off the apr thread
+        void start(void);
+
+        apr_pool_t *getAPRPool() { return mAPRPoolp; }
+        
+private:
+        BOOL                            mPaused;
+
+        // static function passed to APR thread creation routine
+        static void *APR_THREAD_FUNC staticRun(apr_thread_t *apr_threadp, void *datap);
+
+protected:
+        std::string                     mName;
+        LLCondition*            mRunCondition;
+
+        apr_thread_t            *mAPRThreadp;
+        apr_pool_t                      *mAPRPoolp;
+        BOOL                            mIsLocalPool;
+        EThreadStatus           mStatus;
+
+        void setQuitting();
+        
+        // virtual function overridden by subclass -- this will be called when the thread runs
+        virtual void run(void) = 0; 
+        
+        // virtual predicate function -- returns true if the thread should wake up, false if it should sleep.
+        virtual bool runCondition(void);
+
+        // Lock/Unlock Run Condition -- use around modification of any variable used in runCondition()
+        inline void lockData();
+        inline void unlockData();
+        
+        // This is the predicate that decides whether the thread should sleep.  
+        // It should only be called with mRunCondition locked, since the virtual runCondition() function may need to access
+        // data structures that are thread-unsafe.
+        bool shouldSleep(void) { return (mStatus == RUNNING) && (isPaused() || (!runCondition())); }
+
+        // To avoid spurious signals (and the associated context switches) when the condition may or may not have changed, you can do the following:
+        // mRunCondition->lock();
+        // if(!shouldSleep())
+        //     mRunCondition->signal();
+        // mRunCondition->unlock();
+};
+
+//============================================================================
+
+class LLMutex
+{
+public:
+        LLMutex(apr_pool_t *apr_poolp); // Defaults to global pool, could use the thread pool as well.
+        ~LLMutex();
+        
+        void lock();            // blocks
+        void unlock();
+        bool isLocked();        // non-blocking, but does do a lock/unlock so not free
+        
+protected:
+        apr_thread_mutex_t *mAPRMutexp;
+        apr_pool_t                      *mAPRPoolp;
+        BOOL                            mIsLocalPool;
+};
+
+// Actually a condition/mutex pair (since each condition needs to be associated with a mutex).
+class LLCondition : public LLMutex
+{
+public:
+        LLCondition(apr_pool_t *apr_poolp); // Defaults to global pool, could use the thread pool as well.
+        ~LLCondition();
+        
+        void wait();            // blocks
+        void signal();
+        void broadcast();
+        
+protected:
+        apr_thread_cond_t *mAPRCondp;
+};
+
+class LLMutexLock
+{
+public:
+        LLMutexLock(LLMutex* mutex)
+        {
+                mMutex = mutex;
+                mMutex->lock();
+        }
+        ~LLMutexLock()
+        {
+                mMutex->unlock();
+        }
+private:
+        LLMutex* mMutex;
+};
+
+//============================================================================
+
+void LLThread::lockData()
+{
+        mRunCondition->lock();
+}
+
+void LLThread::unlockData()
+{
+        mRunCondition->unlock();
+}
+
+
+//============================================================================
+
+#endif // LL_LLTHREAD_H