Merged in SL-17219 (pull request #992)

SL-17219

7 files changed, 177 insertions, 214 deletions

diff --git a/indra/llcommon/llapr.cpp b/indra/llcommon/llapr.cpp
index db94765871..b537102510 100644
--- a/indra/llcommon/llapr.cpp
+++ b/indra/llcommon/llapr.cpp
@@ -526,6 +526,7 @@ S32 LLAPRFile::seek(apr_file_t* file_handle, apr_seek_where_t where, S32 offset)
 //static
 S32 LLAPRFile::readEx(const std::string& filename, void *buf, S32 offset, S32 nbytes, LLVolatileAPRPool* pool)
 {
+    LL_PROFILE_ZONE_SCOPED;
 	//*****************************************
 	LLAPRFilePoolScope scope(pool);
 	apr_file_t* file_handle = open(filename, scope.getVolatileAPRPool(), APR_READ|APR_BINARY); 
@@ -570,6 +571,7 @@ S32 LLAPRFile::readEx(const std::string& filename, void *buf, S32 offset, S32 nb
 //static
 S32 LLAPRFile::writeEx(const std::string& filename, void *buf, S32 offset, S32 nbytes, LLVolatileAPRPool* pool)
 {
+    LL_PROFILE_ZONE_SCOPED;
 	apr_int32_t flags = APR_CREATE|APR_WRITE|APR_BINARY;
 	if (offset < 0)
 	{
diff --git a/indra/llcommon/llqueuedthread.cpp b/indra/llcommon/llqueuedthread.cpp
index 8cef4293cd..871c42f7ee 100644
--- a/indra/llcommon/llqueuedthread.cpp
+++ b/indra/llcommon/llqueuedthread.cpp
@@ -26,20 +26,25 @@
 #include "linden_common.h"
 #include "llqueuedthread.h"
 
+#include <chrono>
+
 #include "llstl.h"
 #include "lltimer.h"	// ms_sleep()
-#include "lltracethreadrecorder.h"
+#include "llmutex.h"
 
 //============================================================================
 
 // MAIN THREAD
 LLQueuedThread::LLQueuedThread(const std::string& name, bool threaded, bool should_pause) :
-	LLThread(name),
-	mThreaded(threaded),
-	mIdleThread(TRUE),
-	mNextHandle(0),
-	mStarted(FALSE)
+    LLThread(name),
+    mThreaded(threaded),
+    mIdleThread(TRUE),
+    mNextHandle(0),
+    mStarted(FALSE),
+    mRequestQueue(name, 1024 * 1024)
 {
+    mMainQueue = LL::WorkQueue::getInstance("mainloop");
+
 	if (mThreaded)
 	{
 		if(should_pause)
@@ -104,6 +109,8 @@ void LLQueuedThread::shutdown()
 	{
 		LL_WARNS() << "~LLQueuedThread() called with active requests: " << active_count << LL_ENDL;
 	}
+
+    mRequestQueue.close();
 }
 
 //----------------------------------------------------------------------------
@@ -112,6 +119,7 @@ void LLQueuedThread::shutdown()
 // virtual
 S32 LLQueuedThread::update(F32 max_time_ms)
 {
+    LL_PROFILE_ZONE_SCOPED;
 	if (!mStarted)
 	{
 		if (!mThreaded)
@@ -125,29 +133,30 @@ S32 LLQueuedThread::update(F32 max_time_ms)
 
 S32 LLQueuedThread::updateQueue(F32 max_time_ms)
 {
-	F64 max_time = (F64)max_time_ms * .001;
-	LLTimer timer;
-	S32 pending = 1;
-
+    LL_PROFILE_ZONE_SCOPED;
 	// Frame Update
 	if (mThreaded)
 	{
-		pending = getPending();
-		if(pending > 0)
+        // schedule a call to threadedUpdate for every call to updateQueue
+        mRequestQueue.post([=]() 
+            {
+                LL_PROFILE_ZONE_NAMED_CATEGORY_THREAD("qt - update");
+                mIdleThread = FALSE;
+                threadedUpdate(); 
+                mIdleThread = TRUE;
+            }
+        );
+		if(getPending() > 0)
 		{
-		unpause();
-	}
+		    unpause();
+	    }
 	}
 	else
 	{
-		while (pending > 0)
-		{
-			pending = processNextRequest();
-			if (max_time && timer.getElapsedTimeF64() > max_time)
-				break;
-		}
+        mRequestQueue.runFor(std::chrono::microseconds((int) (max_time_ms*1000.f)));
+        threadedUpdate();
 	}
-	return pending;
+	return getPending();
 }
 
 void LLQueuedThread::incQueue()
@@ -166,11 +175,7 @@ void LLQueuedThread::incQueue()
 // May be called from any thread
 S32 LLQueuedThread::getPending()
 {
-	S32 res;
-	lockData();
-	res = mRequestQueue.size();
-	unlockData();
-	return res;
+	return mRequestQueue.size();
 }
 
 // MAIN thread
@@ -195,35 +200,28 @@ void LLQueuedThread::waitOnPending()
 // MAIN thread
 void LLQueuedThread::printQueueStats()
 {
-	lockData();
-	if (!mRequestQueue.empty())
+    U32 size = mRequestQueue.size();
+	if (size > 0)
 	{
-		QueuedRequest *req = *mRequestQueue.begin();
-		LL_INFOS() << llformat("Pending Requests:%d Current status:%d", mRequestQueue.size(), req->getStatus()) << LL_ENDL;
+		LL_INFOS() << llformat("Pending Requests:%d ", mRequestQueue.size()) << LL_ENDL;
 	}
 	else
 	{
 		LL_INFOS() << "Queued Thread Idle" << LL_ENDL;
 	}
-	unlockData();
 }
 
 // MAIN thread
 LLQueuedThread::handle_t LLQueuedThread::generateHandle()
 {
-	lockData();
-	while ((mNextHandle == nullHandle()) || (mRequestHash.find(mNextHandle)))
-	{
-		mNextHandle++;
-	}
-	const LLQueuedThread::handle_t res = mNextHandle++;
-	unlockData();
+    U32 res = ++mNextHandle;
 	return res;
 }
 
 // MAIN thread
 bool LLQueuedThread::addRequest(QueuedRequest* req)
 {
+    LL_PROFILE_ZONE_SCOPED;
 	if (mStatus == QUITTING)
 	{
 		return false;
@@ -231,14 +229,14 @@ bool LLQueuedThread::addRequest(QueuedRequest* req)
 	
 	lockData();
 	req->setStatus(STATUS_QUEUED);
-	mRequestQueue.insert(req);
-	mRequestHash.insert(req);
+    mRequestHash.insert(req);
 #if _DEBUG
 // 	LL_INFOS() << llformat("LLQueuedThread::Added req [%08d]",handle) << LL_ENDL;
 #endif
 	unlockData();
 
-	incQueue();
+    llassert(!mDataLock->isSelfLocked());
+    mRequestQueue.post([this, req]() { processRequest(req); });
 
 	return true;
 }
@@ -246,6 +244,7 @@ bool LLQueuedThread::addRequest(QueuedRequest* req)
 // MAIN thread
 bool LLQueuedThread::waitForResult(LLQueuedThread::handle_t handle, bool auto_complete)
 {
+    LL_PROFILE_ZONE_SCOPED;
 	llassert (handle != nullHandle());
 	bool res = false;
 	bool waspaused = isPaused();
@@ -312,6 +311,7 @@ LLQueuedThread::status_t LLQueuedThread::getRequestStatus(handle_t handle)
 
 void LLQueuedThread::abortRequest(handle_t handle, bool autocomplete)
 {
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_THREAD;
 	lockData();
 	QueuedRequest* req = (QueuedRequest*)mRequestHash.find(handle);
 	if (req)
@@ -333,30 +333,9 @@ void LLQueuedThread::setFlags(handle_t handle, U32 flags)
 	unlockData();
 }
 
-void LLQueuedThread::setPriority(handle_t handle, U32 priority)
-{
-	lockData();
-	QueuedRequest* req = (QueuedRequest*)mRequestHash.find(handle);
-	if (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();
-}
-
 bool LLQueuedThread::completeRequest(handle_t handle)
 {
+    LL_PROFILE_ZONE_SCOPED;
 	bool res = false;
 	lockData();
 	QueuedRequest* req = (QueuedRequest*)mRequestHash.find(handle);
@@ -399,89 +378,115 @@ bool LLQueuedThread::check()
 //============================================================================
 // Runs on its OWN thread
 
-S32 LLQueuedThread::processNextRequest()
+void LLQueuedThread::processRequest(LLQueuedThread::QueuedRequest* req)
 {
-	QueuedRequest *req;
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_THREAD;
+
+    mIdleThread = FALSE;
+    //threadedUpdate();
+
 	// Get next request from pool
 	lockData();
 	
-	while(1)
-	{
-		req = NULL;
-		if (mRequestQueue.empty())
-		{
-			break;
-		}
-		req = *mRequestQueue.begin();
-		mRequestQueue.erase(mRequestQueue.begin());
-		if ((req->getFlags() & FLAG_ABORT) || (mStatus == QUITTING))
-		{
-			req->setStatus(STATUS_ABORTED);
-			req->finishRequest(false);
-			if (req->getFlags() & FLAG_AUTO_COMPLETE)
-			{
-				mRequestHash.erase(req);
-				req->deleteRequest();
-// 				check();
-			}
-			continue;
-		}
-		llassert_always(req->getStatus() == STATUS_QUEUED);
-		break;
-	}
-	U32 start_priority = 0 ;
-	if (req)
-	{
-		req->setStatus(STATUS_INPROGRESS);
-		start_priority = req->getPriority();
-	}
-	unlockData();
-
-	// 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)
+	if ((req->getFlags() & FLAG_ABORT) || (mStatus == QUITTING))
 	{
-		// process request		
-		bool complete = req->processRequest();
-
-		if (complete)
+        LL_PROFILE_ZONE_NAMED_CATEGORY_THREAD("qtpr - abort");
+		req->setStatus(STATUS_ABORTED);
+		req->finishRequest(false);
+		if (req->getFlags() & FLAG_AUTO_COMPLETE)
 		{
-			lockData();
-			req->setStatus(STATUS_COMPLETE);
-			req->finishRequest(true);
-			if (req->getFlags() & FLAG_AUTO_COMPLETE)
-			{
-				mRequestHash.erase(req);
-				req->deleteRequest();
+			mRequestHash.erase(req);
+			req->deleteRequest();
 // 				check();
-			}
-			unlockData();
 		}
-		else
-		{
-			lockData();
-			req->setStatus(STATUS_QUEUED);
-			mRequestQueue.insert(req);
-			unlockData();
-			if (mThreaded && start_priority < PRIORITY_NORMAL)
-			{
-				ms_sleep(1); // sleep the thread a little
-			}
-		}
-		
-		LLTrace::get_thread_recorder()->pushToParent();
+        unlockData();
 	}
+    else
+    {
+        llassert_always(req->getStatus() == STATUS_QUEUED);
+
+        if (req)
+        {
+            req->setStatus(STATUS_INPROGRESS);
+        }
+        unlockData();
+
+        // 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 = req->processRequest();
+
+            if (complete)
+            {
+                LL_PROFILE_ZONE_NAMED_CATEGORY_THREAD("qtpr - complete");
+                lockData();
+                req->setStatus(STATUS_COMPLETE);
+                req->finishRequest(true);
+                if (req->getFlags() & FLAG_AUTO_COMPLETE)
+                {
+                    mRequestHash.erase(req);
+                    req->deleteRequest();
+                    // 				check();
+                }
+                unlockData();
+            }
+            else
+            {
+                LL_PROFILE_ZONE_NAMED_CATEGORY_THREAD("qtpr - retry");
+                //put back on queue and try again in 0.1ms
+                lockData();
+                req->setStatus(STATUS_QUEUED);
+                
+                unlockData();
+
+                llassert(!mDataLock->isSelfLocked());
+
+#if 0
+                // try again on next frame
+                // NOTE: tried using "post" with a time in the future, but this
+                // would invariably cause this thread to wait for a long time (10+ ms)
+                // while work is pending
+                bool ret = LL::WorkQueue::postMaybe(
+                    mMainQueue,
+                    [=]()
+                    {
+                        LL_PROFILE_ZONE_NAMED("processRequest - retry");
+                        mRequestQueue.post([=]()
+                            {
+                                LL_PROFILE_ZONE_NAMED("processRequest - retry"); // <-- not redundant, track retry on both queues
+                                processRequest(req);
+                            });
+                    });
+                llassert(ret);
+#else
+                using namespace std::chrono_literals;
+                auto retry_time = LL::WorkQueue::TimePoint::clock::now() + 16ms;
+                mRequestQueue.post([=]
+                    {
+                        LL_PROFILE_ZONE_NAMED("processRequest - retry");
+                        while (LL::WorkQueue::TimePoint::clock::now() < retry_time)
+                        {
+                            std::this_thread::yield(); //note: don't use LLThread::yield here to avoid 
+                        }
+                        processRequest(req);
+                    });
+#endif
+                
+            }
+        }
+    }
 
-	S32 pending = getPending();
-	return pending;
+    mIdleThread = TRUE;
 }
 
 // virtual
 bool LLQueuedThread::runCondition()
 {
 	// mRunCondition must be locked here
-	if (mRequestQueue.empty() && mIdleThread)
+	if (mRequestQueue.size() == 0 && mIdleThread)
 		return false;
 	else
 		return true;
@@ -495,18 +500,13 @@ void LLQueuedThread::run()
 	startThread();
 	mStarted = TRUE;
 	
-	while (1)
+
+	/*while (1)
 	{
+        LL_PROFILE_ZONE_SCOPED;
 		// this will block on the condition until runCondition() returns true, the thread is unpaused, or the thread leaves the RUNNING state.
 		checkPause();
 		
-		if (isQuitting())
-		{
-			LLTrace::get_thread_recorder()->pushToParent();
-			endThread();
-			break;
-		}
-
 		mIdleThread = FALSE;
 
 		threadedUpdate();
@@ -515,12 +515,18 @@ void LLQueuedThread::run()
 
 		if (pending_work == 0)
 		{
+            //LL_PROFILE_ZONE_NAMED("LLQueuedThread - sleep");
 			mIdleThread = TRUE;
-			ms_sleep(1);
+			//ms_sleep(1);
 		}
 		//LLThread::yield(); // thread should yield after each request		
-	}
+	}*/
+    mRequestQueue.runUntilClose();
+
+    endThread();
 	LL_INFOS() << "LLQueuedThread " << mName << " EXITING." << LL_ENDL;
+
+    
 }
 
 // virtual
@@ -540,10 +546,9 @@ void LLQueuedThread::threadedUpdate()
 
 //============================================================================
 
-LLQueuedThread::QueuedRequest::QueuedRequest(LLQueuedThread::handle_t handle, U32 priority, U32 flags) :
+LLQueuedThread::QueuedRequest::QueuedRequest(LLQueuedThread::handle_t handle, U32 flags) :
 	LLSimpleHashEntry<LLQueuedThread::handle_t>(handle),
 	mStatus(STATUS_UNKNOWN),
-	mPriority(priority),
 	mFlags(flags)
 {
 }
diff --git a/indra/llcommon/llqueuedthread.h b/indra/llcommon/llqueuedthread.h
index 5d3f873646..6b82ccc434 100644
--- a/indra/llcommon/llqueuedthread.h
+++ b/indra/llcommon/llqueuedthread.h
@@ -36,6 +36,7 @@
 
 #include "llthread.h"
 #include "llsimplehash.h"
+#include "workqueue.h"
 
 //============================================================================
 // Note: ~LLQueuedThread is O(N) N=# of queued threads, assumed to be small
@@ -45,15 +46,6 @@ class LL_COMMON_API LLQueuedThread : public LLThread
 {
 	//------------------------------------------------------------------------
 public:
-	enum priority_t {
-		PRIORITY_IMMEDIATE = 0x7FFFFFFF,
-		PRIORITY_URGENT =    0x40000000,
-		PRIORITY_HIGH =      0x30000000,
-		PRIORITY_NORMAL =    0x20000000,
-		PRIORITY_LOW =       0x10000000,
-		PRIORITY_LOWBITS =   0x0FFFFFFF,
-		PRIORITY_HIGHBITS =  0x70000000
-	};
 	enum status_t {
 		STATUS_EXPIRED = -1,
 		STATUS_UNKNOWN = 0,
@@ -82,28 +74,17 @@ public:
 		virtual ~QueuedRequest(); // use deleteRequest()
 		
 	public:
-		QueuedRequest(handle_t handle, U32 priority, U32 flags = 0);
+		QueuedRequest(handle_t handle, U32 flags = 0);
 
 		status_t getStatus()
 		{
 			return mStatus;
 		}
-		U32 getPriority() const
-		{
-			return mPriority;
-		}
 		U32 getFlags() const
 		{
 			return mFlags;
 		}
-		bool higherPriority(const QueuedRequest& second) const
-		{
-			if ( mPriority == second.mPriority)
-				return mHashKey < second.mHashKey;
-			else
-				return mPriority > second.mPriority;
-		}
-
+		
 	protected:
 		status_t setStatus(status_t newstatus)
 		{
@@ -121,28 +102,11 @@ public:
 		virtual void finishRequest(bool completed); // Always called from thread after request has completed or aborted
 		virtual void deleteRequest(); // Only method to delete a request
 
-		void setPriority(U32 pri)
-		{
-			// Only do this on a request that is not in a queued list!
-			mPriority = pri;
-		};
-		
 	protected:
 		LLAtomicBase<status_t> mStatus;
-		U32 mPriority;
 		U32 mFlags;
 	};
 
-protected:
-	struct queued_request_less
-	{
-		bool operator()(const QueuedRequest* lhs, const QueuedRequest* rhs) const
-		{
-			return lhs->higherPriority(*rhs); // higher priority in front of queue (set)
-		}
-	};
-
-
 	//------------------------------------------------------------------------
 	
 public:
@@ -167,7 +131,7 @@ private:
 protected:
 	handle_t generateHandle();
 	bool addRequest(QueuedRequest* req);
-	S32  processNextRequest(void);
+	void processRequest(QueuedRequest* req);
 	void incQueue();
 
 public:
@@ -186,7 +150,6 @@ public:
 	status_t getRequestStatus(handle_t handle);
 	void abortRequest(handle_t handle, bool autocomplete);
 	void setFlags(handle_t handle, U32 flags);
-	void setPriority(handle_t handle, U32 priority);
 	bool completeRequest(handle_t handle);
 	// This is public for support classes like LLWorkerThread,
 	// but generally the methods above should be used.
@@ -200,8 +163,10 @@ protected:
 	BOOL mStarted;  // required when mThreaded is false to call startThread() from update()
 	LLAtomicBool mIdleThread; // request queue is empty (or we are quitting) and the thread is idle
 	
-	typedef std::set<QueuedRequest*, queued_request_less> request_queue_t;
-	request_queue_t mRequestQueue;
+	//typedef std::set<QueuedRequest*, queued_request_less> request_queue_t;
+	//request_queue_t mRequestQueue;
+    LL::WorkQueue mRequestQueue;
+    LL::WorkQueue::weak_t mMainQueue;
 
 	enum { REQUEST_HASH_SIZE = 512 }; // must be power of 2
 	typedef LLSimpleHash<handle_t, REQUEST_HASH_SIZE> request_hash_t;
diff --git a/indra/llcommon/lltimer.cpp b/indra/llcommon/lltimer.cpp
index aaa6df325c..b250bc3e1c 100644
--- a/indra/llcommon/lltimer.cpp
+++ b/indra/llcommon/lltimer.cpp
@@ -64,7 +64,8 @@ LLTimer* LLTimer::sTimer = NULL;
 #if LL_WINDOWS
 void ms_sleep(U32 ms)
 {
-	Sleep(ms);
+    LL_PROFILE_ZONE_SCOPED;
+    std::this_thread::sleep_for(std::chrono::microseconds(ms));
 }
 
 U32 micro_sleep(U64 us, U32 max_yields)
diff --git a/indra/llcommon/llworkerthread.cpp b/indra/llcommon/llworkerthread.cpp
index 4b91b2caca..02ce4823b8 100644
--- a/indra/llcommon/llworkerthread.cpp
+++ b/indra/llcommon/llworkerthread.cpp
@@ -133,11 +133,11 @@ S32 LLWorkerThread::update(F32 max_time_ms)
 
 //----------------------------------------------------------------------------
 
-LLWorkerThread::handle_t LLWorkerThread::addWorkRequest(LLWorkerClass* workerclass, S32 param, U32 priority)
+LLWorkerThread::handle_t LLWorkerThread::addWorkRequest(LLWorkerClass* workerclass, S32 param)
 {
 	handle_t handle = generateHandle();
 	
-	WorkRequest* req = new WorkRequest(handle, priority, workerclass, param);
+	WorkRequest* req = new WorkRequest(handle, workerclass, param);
 
 	bool res = addRequest(req);
 	if (!res)
@@ -160,8 +160,8 @@ void LLWorkerThread::deleteWorker(LLWorkerClass* workerclass)
 //============================================================================
 // Runs on its OWN thread
 
-LLWorkerThread::WorkRequest::WorkRequest(handle_t handle, U32 priority, LLWorkerClass* workerclass, S32 param) :
-	LLQueuedThread::QueuedRequest(handle, priority),
+LLWorkerThread::WorkRequest::WorkRequest(handle_t handle, LLWorkerClass* workerclass, S32 param) :
+	LLQueuedThread::QueuedRequest(handle),
 	mWorkerClass(workerclass),
 	mParam(param)
 {
@@ -180,6 +180,7 @@ void LLWorkerThread::WorkRequest::deleteRequest()
 // virtual
 bool LLWorkerThread::WorkRequest::processRequest()
 {
+    LL_PROFILE_ZONE_SCOPED;
 	LLWorkerClass* workerclass = getWorkerClass();
 	workerclass->setWorking(true);
 	bool complete = workerclass->doWork(getParam());
@@ -190,6 +191,7 @@ bool LLWorkerThread::WorkRequest::processRequest()
 // virtual
 void LLWorkerThread::WorkRequest::finishRequest(bool completed)
 {
+    LL_PROFILE_ZONE_SCOPED;
 	LLWorkerClass* workerclass = getWorkerClass();
 	workerclass->finishWork(getParam(), completed);
 	U32 flags = LLWorkerClass::WCF_WORK_FINISHED | (completed ? 0 : LLWorkerClass::WCF_WORK_ABORTED);
@@ -203,7 +205,6 @@ LLWorkerClass::LLWorkerClass(LLWorkerThread* workerthread, const std::string& na
 	: mWorkerThread(workerthread),
 	  mWorkerClassName(name),
 	  mRequestHandle(LLWorkerThread::nullHandle()),
-	  mRequestPriority(LLWorkerThread::PRIORITY_NORMAL),
 	  mMutex(),
 	  mWorkFlags(0)
 {
@@ -292,7 +293,7 @@ bool LLWorkerClass::yield()
 //----------------------------------------------------------------------------
 
 // calls startWork, adds doWork() to queue
-void LLWorkerClass::addWork(S32 param, U32 priority)
+void LLWorkerClass::addWork(S32 param)
 {
 	mMutex.lock();
 	llassert_always(!(mWorkFlags & (WCF_WORKING|WCF_HAVE_WORK)));
@@ -306,7 +307,7 @@ void LLWorkerClass::addWork(S32 param, U32 priority)
 	startWork(param);
 	clearFlags(WCF_WORK_FINISHED|WCF_WORK_ABORTED);
 	setFlags(WCF_HAVE_WORK);
-	mRequestHandle = mWorkerThread->addWorkRequest(this, param, priority);
+	mRequestHandle = mWorkerThread->addWorkRequest(this, param);
 	mMutex.unlock();
 }
 
@@ -321,7 +322,6 @@ void LLWorkerClass::abortWork(bool autocomplete)
 	if (mRequestHandle != LLWorkerThread::nullHandle())
 	{
 		mWorkerThread->abortRequest(mRequestHandle, autocomplete);
-		mWorkerThread->setPriority(mRequestHandle, LLQueuedThread::PRIORITY_IMMEDIATE);
 		setFlags(WCF_ABORT_REQUESTED);
 	}
 	mMutex.unlock();
@@ -395,16 +395,5 @@ void LLWorkerClass::scheduleDelete()
 	}
 }
 
-void LLWorkerClass::setPriority(U32 priority)
-{
-	mMutex.lock();
-	if (mRequestHandle != LLWorkerThread::nullHandle() && mRequestPriority != priority)
-	{
-		mRequestPriority = priority;
-		mWorkerThread->setPriority(mRequestHandle, priority);
-	}
-	mMutex.unlock();
-}
-
 //============================================================================
 
diff --git a/indra/llcommon/llworkerthread.h b/indra/llcommon/llworkerthread.h
index 0387e75c65..06bbb7369e 100644
--- a/indra/llcommon/llworkerthread.h
+++ b/indra/llcommon/llworkerthread.h
@@ -56,7 +56,7 @@ public:
 		virtual ~WorkRequest(); // use deleteRequest()
 		
 	public:
-		WorkRequest(handle_t handle, U32 priority, LLWorkerClass* workerclass, S32 param);
+		WorkRequest(handle_t handle, LLWorkerClass* workerclass, S32 param);
 
 		S32 getParam()
 		{
@@ -90,7 +90,7 @@ public:
 
 	/*virtual*/ S32 update(F32 max_time_ms);
 	
-	handle_t addWorkRequest(LLWorkerClass* workerclass, S32 param, U32 priority = PRIORITY_NORMAL);
+	handle_t addWorkRequest(LLWorkerClass* workerclass, S32 param);
 	
 	S32 getNumDeletes() { return (S32)mDeleteList.size(); } // debug
 
@@ -151,10 +151,6 @@ public:
 	bool isWorking() { return getFlags(WCF_WORKING); }
 	bool wasAborted() { return getFlags(WCF_ABORT_REQUESTED); }
 
-	// setPriority(): changes the priority of a request
-	void setPriority(U32 priority);
-	U32  getPriority() { return mRequestPriority; }
-		
 	const std::string& getName() const { return mWorkerClassName; }
 
 protected:
@@ -169,7 +165,7 @@ protected:
 	void setWorkerThread(LLWorkerThread* workerthread);
 
 	// addWork(): calls startWork, adds doWork() to queue
-	void addWork(S32 param, U32 priority = LLWorkerThread::PRIORITY_NORMAL);
+	void addWork(S32 param);
 
 	// abortWork(): requests that work be aborted
 	void abortWork(bool autocomplete);
@@ -193,7 +189,6 @@ protected:
 	LLWorkerThread* mWorkerThread;
 	std::string mWorkerClassName;
 	handle_t mRequestHandle;
-	U32 mRequestPriority; // last priority set
 
 private:
 	LLMutex mMutex;
diff --git a/indra/llcommon/workqueue.h b/indra/llcommon/workqueue.h
index 96574a18b9..784327f929 100644
--- a/indra/llcommon/workqueue.h
+++ b/indra/llcommon/workqueue.h
@@ -162,9 +162,15 @@ namespace LL
                        CALLABLE&& callable);
 
         template <typename CALLABLE>
+        bool tryPost(const TimePoint& time, CALLABLE&& callable)
+        {
+            return mQueue.tryPush(TimedWork(time, std::move(callable)));
+        }
+
+        template <typename CALLABLE>
         bool tryPost(CALLABLE&& callable)
         {
-            return mQueue.tryPush(TimedWork(TimePoint::clock::now(), std::move(callable)));
+            return mQueue.tryPush(TimePoint::clock::now(), std::move(callable));
         }
 
         /*------------------------- handshake API --------------------------*/