Second Life viewer sources 1.14.0.0

1 files changed, 109 insertions, 86 deletions

diff --git a/linden/indra/llcommon/llqueuedthread.cpp b/linden/indra/llcommon/llqueuedthread.cpp
index 565836b..2e4324b 100644
--- a/linden/indra/llcommon/llqueuedthread.cpp
+++ b/linden/indra/llcommon/llqueuedthread.cpp
@@ -31,10 +31,9 @@
 //============================================================================
 
 // MAIN THREAD
-LLQueuedThread::LLQueuedThread(const std::string& name, bool threaded, bool runalways) :
+LLQueuedThread::LLQueuedThread(const std::string& name, bool threaded) :
         LLThread(name),
         mThreaded(threaded),
-        mRunAlways(runalways),
         mIdleThread(TRUE),
         mNextHandle(0)
 {
@@ -47,6 +46,12 @@ LLQueuedThread::LLQueuedThread(const std::string& name, bool threaded, bool runa
 // MAIN THREAD
 LLQueuedThread::~LLQueuedThread()
 {
+        shutdown();
+        // ~LLThread() will be called here
+}
+
+void LLQueuedThread::shutdown()
+{
         setQuitting();
 
         unpause(); // MAIN THREAD
@@ -73,61 +78,69 @@ LLQueuedThread::~LLQueuedThread()
         }
 
         QueuedRequest* req;
+        S32 active_count = 0;
         while ( (req = (QueuedRequest*)mRequestHash.pop_element()) )
         {
+                if (req->getStatus() == STATUS_QUEUED || req->getStatus() == STATUS_INPROGRESS)
+                {
+                        ++active_count;
+                }
                 req->deleteRequest();
         }
-        
-        // ~LLThread() will be called here
+        if (active_count)
+        {
+                llwarns << "~LLQueuedThread() called with active requests: " << active_count << llendl;
+        }
 }
 
 //----------------------------------------------------------------------------
 
 // MAIN THREAD
-void LLQueuedThread::update(U32 ms_elapsed)
+// virtual
+S32 LLQueuedThread::update(U32 max_time_ms)
 {
-        updateQueue(0);
+        return updateQueue(max_time_ms);
 }
 
-void LLQueuedThread::updateQueue(S32 inc)
+S32 LLQueuedThread::updateQueue(U32 max_time_ms)
 {
-        // If mRunAlways == TRUE, unpause the thread whenever we put something into the queue.
-        // If mRunAlways == FALSE, we only unpause the thread when updateQueue() is called from the main loop (i.e. between rendered frames)
-        
-        if (inc == 0) // Frame Update
+        F64 max_time = (F64)max_time_ms * .001;
+        LLTimer timer;
+        S32 pending = 1;
+
+        // Frame Update
+        if (mThreaded)
         {
-                if (mThreaded)
-                {
-                        unpause();
-                        wake(); // Wake the thread up if necessary.
-                }
-                else
+                pending = getPending();
+                unpause();
+        }
+        else
+        {
+                while (pending > 0)
                 {
-                        while (processNextRequest() > 0)
-                                ;
+                        pending = processNextRequest();
+                        if (max_time && timer.getElapsedTimeF64() > max_time)
+                                break;
                 }
         }
-        else
+        return pending;
+}
+
+void LLQueuedThread::incQueue()
+{
+        // Something has been added to the queue
+        if (!isPaused())
         {
-                // Something has been added to the queue
-                if (mRunAlways)
+                if (mThreaded)
                 {
-                        if (mThreaded)
-                        {
-                                wake(); // Wake the thread up if necessary.
-                        }
-                        else
-                        {
-                                while(processNextRequest() > 0)
-                                        ;
-                        }
+                        wake(); // Wake the thread up if necessary.
                 }
         }
 }
 
 //virtual
 // May be called from any thread
-S32 LLQueuedThread::getPending(bool child_thread)
+S32 LLQueuedThread::getPending()
 {
         S32 res;
         lockData();
@@ -141,7 +154,7 @@ void LLQueuedThread::waitOnPending()
 {
         while(1)
         {
-                updateQueue(0);
+                update(0);
 
                 if (mIdleThread)
                 {
@@ -200,7 +213,7 @@ bool LLQueuedThread::addRequest(QueuedRequest* req)
 #endif
         unlockData();
 
-        updateQueue(1);
+        incQueue();
 
         return true;
 }
@@ -214,7 +227,7 @@ bool LLQueuedThread::waitForResult(LLQueuedThread::handle_t handle, bool auto_co
         bool done = false;
         while(!done)
         {
-                updateQueue(0); // unpauses
+                update(0); // unpauses
                 lockData();
                 QueuedRequest* req = (QueuedRequest*)mRequestHash.find(handle);
                 if (!req)
@@ -272,51 +285,47 @@ LLQueuedThread::status_t LLQueuedThread::getRequestStatus(handle_t handle)
         return res;
 }
 
-LLQueuedThread::status_t LLQueuedThread::abortRequest(handle_t handle, U32 flags)
+void LLQueuedThread::abortRequest(handle_t handle, bool autocomplete)
 {
-        status_t res = STATUS_EXPIRED;
         lockData();
         QueuedRequest* req = (QueuedRequest*)mRequestHash.find(handle);
         if (req)
         {
-                res = req->abortRequest(flags);
-                if ((flags & AUTO_COMPLETE) && (res == STATUS_COMPLETE))
-                {
-                        mRequestHash.erase(handle);
-                        req->deleteRequest();
-//                      check();
-                }
-#if _DEBUG
-//              llinfos << llformat("LLQueuedThread::Aborted req [%08d]",handle) << llendl;
-#endif
+                req->setFlags(FLAG_ABORT | (autocomplete ? FLAG_AUTO_COMPLETE : 0));
         }
         unlockData();
-        return res;
 }
 
 // MAIN thread
-LLQueuedThread::status_t LLQueuedThread::setFlags(handle_t handle, U32 flags)
+void LLQueuedThread::setFlags(handle_t handle, U32 flags)
 {
-        status_t res = STATUS_EXPIRED;
         lockData();
         QueuedRequest* req = (QueuedRequest*)mRequestHash.find(handle);
         if (req)
         {
-                res = req->setFlags(flags);
+                req->setFlags(flags);
         }
         unlockData();
-        return res;
 }
 
 void LLQueuedThread::setPriority(handle_t handle, U32 priority)
 {
         lockData();
         QueuedRequest* req = (QueuedRequest*)mRequestHash.find(handle);
-        if (req && (req->getStatus() == STATUS_QUEUED))
+        if (req)
         {
-                llverify(mRequestQueue.erase(req) == 1);
-                req->setPriority(priority);
-                mRequestQueue.insert(req);
+                if(req->getStatus() == STATUS_INPROGRESS)
+                {
+                        // not in list
+                        req->setPriority(priority);
+                }
+                else if(req->getStatus() == STATUS_QUEUED)
+                {
+                        // remove from list then re-insert
+                        llverify(mRequestQueue.erase(req) == 1);
+                        req->setPriority(priority);
+                        mRequestQueue.insert(req);
+                }
         }
         unlockData();
 }
@@ -328,9 +337,10 @@ bool LLQueuedThread::completeRequest(handle_t handle)
         QueuedRequest* req = (QueuedRequest*)mRequestHash.find(handle);
         if (req)
         {
-                llassert(req->getStatus() != STATUS_QUEUED && req->getStatus() != STATUS_ABORT);
+                llassert_always(req->getStatus() != STATUS_QUEUED);
+                llassert_always(req->getStatus() != STATUS_INPROGRESS);
 #if _DEBUG
-//              llinfos << llformat("LLQueuedThread::Completed req [%08d]",handle) << llendl;
+//              llinfos << llformat("LLQueuedThread::Completed req [%08d]",handle) << llendl;
 #endif
                 mRequestHash.erase(handle);
                 req->deleteRequest();
@@ -364,28 +374,34 @@ bool LLQueuedThread::check()
 //============================================================================
 // Runs on its OWN thread
 
-int LLQueuedThread::processNextRequest()
+S32 LLQueuedThread::processNextRequest()
 {
-        QueuedRequest *req = 0;
+        QueuedRequest *req;
         // Get next request from pool
         lockData();
         while(1)
         {
-                if (!mRequestQueue.empty())
+                req = NULL;
+                if (mRequestQueue.empty())
                 {
-                        req = *mRequestQueue.begin();
-                        mRequestQueue.erase(mRequestQueue.begin());
+                        break;
                 }
-                if (req && req->getStatus() == STATUS_ABORT)
+                req = *mRequestQueue.begin();
+                mRequestQueue.erase(mRequestQueue.begin());
+                if ((req->getFlags() & FLAG_ABORT) || (mStatus == QUITTING))
                 {
                         req->setStatus(STATUS_ABORTED);
-                        req = 0;
-                }
-                else
-                {
-                        llassert (!req || req->getStatus() == STATUS_QUEUED)
-                        break;
+                        req->finishRequest(false);
+                        if (req->getFlags() & FLAG_AUTO_COMPLETE)
+                        {
+                                mRequestHash.erase(req);
+                                req->deleteRequest();
+//                              check();
+                        }
+                        continue;
                 }
+                llassert_always(req->getStatus() == STATUS_QUEUED);
+                break;
         }
         if (req)
         {
@@ -393,22 +409,22 @@ int LLQueuedThread::processNextRequest()
         }
         unlockData();
 
-        // This is the only place we will cal req->setStatus() after
+        // This is the only place we will call req->setStatus() after
         // it has initially been seet to STATUS_QUEUED, so it is
         // safe to access req.
         if (req)
         {
                 // process request
-                bool complete = processRequest(req);
+                bool complete = req->processRequest();
 
                 if (complete)
                 {
                         lockData();
                         req->setStatus(STATUS_COMPLETE);
-                        req->finishRequest();
-                        if (req->getFlags() & AUTO_COMPLETE)
+                        req->finishRequest(true);
+                        if (req->getFlags() & FLAG_AUTO_COMPLETE)
                         {
-                                llverify(mRequestHash.erase(req))
+                                mRequestHash.erase(req);
                                 req->deleteRequest();
 //                              check();
                         }
@@ -419,12 +435,18 @@ int LLQueuedThread::processNextRequest()
                         lockData();
                         req->setStatus(STATUS_QUEUED);
                         mRequestQueue.insert(req);
+                        U32 priority = req->getPriority();
                         unlockData();
+                        if (priority < PRIORITY_NORMAL)
+                        {
+                                ms_sleep(1); // sleep the thread a little
+                        }
                 }
         }
 
-        int res;
-        if (getPending(true) == 0)
+        S32 res;
+        S32 pending = getPending();
+        if (pending == 0)
         {
                 if (isQuitting())
                 {
@@ -437,7 +459,7 @@ int LLQueuedThread::processNextRequest()
         }
         else
         {
-                res = 1;
+                res = pending;
         }
         return res;
 }
@@ -445,13 +467,14 @@ int LLQueuedThread::processNextRequest()
 bool LLQueuedThread::runCondition()
 {
         // mRunCondition must be locked here
-        return (mRequestQueue.empty() && mIdleThread) ? FALSE : TRUE;
+        if (mRequestQueue.empty() && mIdleThread)
+                return false;
+        else
+                return true;
 }
 
 void LLQueuedThread::run()
 {
-        llinfos << "QUEUED THREAD STARTING" << llendl;
-
         while (1)
         {
                 // this will block on the condition until runCondition() returns true, the thread is unpaused, or the thread leaves the RUNNING state.
@@ -474,6 +497,8 @@ void LLQueuedThread::run()
                 {
                         break;
                 }
+
+                //LLThread::yield(); // thread should yield after each request          
         }
 
         llinfos << "QUEUED THREAD " << mName << " EXITING." << llendl;
@@ -491,20 +516,18 @@ LLQueuedThread::QueuedRequest::QueuedRequest(LLQueuedThread::handle_t handle, U3
 
 LLQueuedThread::QueuedRequest::~QueuedRequest()
 {
-        if (mStatus != STATUS_DELETE)
-        {
-                llerrs << "Attemt to directly delete a  LLQueuedThread::QueuedRequest; use deleteRequest()" << llendl;
-        }
+        llassert_always(mStatus == STATUS_DELETE);
 }
 
 //virtual
-void LLQueuedThread::QueuedRequest::finishRequest()
+void LLQueuedThread::QueuedRequest::finishRequest(bool completed)
 {
 }
 
 //virtual
 void LLQueuedThread::QueuedRequest::deleteRequest()
 {
+        llassert_always(mStatus != STATUS_INPROGRESS);
         setStatus(STATUS_DELETE);
         delete this;
 }