From fc424a0db90fd2d2e44e85a19750ad6eaa57b28a Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 9 Dec 2022 13:21:45 -0500
Subject: SL-18809: Add WorkSchedule; remove timestamps from WorkQueue.

For work queues that don't need timestamped tasks, eliminate the overhead of a
priority queue ordered by timestamp. Timestamped task support moves to
WorkSchedule. WorkQueue is a simpler queue that just waits for work.

Both WorkQueue and WorkSchedule can be accessed via new WorkQueueBase API. Of
course the WorkQueueBase API doesn't deal with timestamps, but a WorkSchedule
can be accessed directly to post timestamped tasks and then handled normally
(e.g. by ThreadPool) to run them.

Most ThreadPool functionality migrates to new ThreadPoolBase class, with
template subclass ThreadPoolUsing<WorkQueue> or ThreadPoolUsing<WorkSchedule>
depending on need. ThreadPool is now an alias for ThreadPoolUsing<WorkQueue>.
Importantly, ThreadPoolUsing::getQueue() delivers a reference to the specific
queue subclass type, so you can post timestamped tasks on a queue retrieved
from ThreadPoolUsing<WorkSchedule>::getQueue().

Since ThreadPool is no longer a simple class but an alias for a particular
template specialization, introduce threadpool_fwd.h to forward-declare it.

Recast workqueue_test.cpp to exercise WorkSchedule, since some of the tests
are time-based. A future todo would be to exercise each applicable test with
both WorkQueue and WorkSchedule.
---
 indra/llcommon/threadpool.cpp | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

(limited to 'indra/llcommon/threadpool.cpp')

diff --git a/indra/llcommon/threadpool.cpp b/indra/llcommon/threadpool.cpp
index f49dd40a8b..856306d8f4 100644
--- a/indra/llcommon/threadpool.cpp
+++ b/indra/llcommon/threadpool.cpp
@@ -23,14 +23,15 @@
 #include "llsd.h"
 #include "stringize.h"
 
-LL::ThreadPool::ThreadPool(const std::string& name, size_t threads, size_t capacity):
+LL::ThreadPoolBase::ThreadPoolBase(const std::string& name, size_t threads,
+                                   WorkQueueBase* queue):
     super(name),
-    mQueue(name, capacity),
     mName("ThreadPool:" + name),
-    mThreadCount(getConfiguredWidth(name, threads))
+    mThreadCount(getConfiguredWidth(name, threads)),
+    mQueue(queue)
 {}
 
-void LL::ThreadPool::start()
+void LL::ThreadPoolBase::start()
 {
     for (size_t i = 0; i < mThreadCount; ++i)
     {
@@ -58,17 +59,17 @@ void LL::ThreadPool::start()
         });
 }
 
-LL::ThreadPool::~ThreadPool()
+LL::ThreadPoolBase::~ThreadPoolBase()
 {
     close();
 }
 
-void LL::ThreadPool::close()
+void LL::ThreadPoolBase::close()
 {
-    if (! mQueue.isClosed())
+    if (! mQueue->isClosed())
     {
         LL_DEBUGS("ThreadPool") << mName << " closing queue and joining threads" << LL_ENDL;
-        mQueue.close();
+        mQueue->close();
         for (auto& pair: mThreads)
         {
             LL_DEBUGS("ThreadPool") << mName << " waiting on thread " << pair.first << LL_ENDL;
@@ -78,20 +79,20 @@ void LL::ThreadPool::close()
     }
 }
 
-void LL::ThreadPool::run(const std::string& name)
+void LL::ThreadPoolBase::run(const std::string& name)
 {
     LL_DEBUGS("ThreadPool") << name << " starting" << LL_ENDL;
     run();
     LL_DEBUGS("ThreadPool") << name << " stopping" << LL_ENDL;
 }
 
-void LL::ThreadPool::run()
+void LL::ThreadPoolBase::run()
 {
-    mQueue.runUntilClose();
+    mQueue->runUntilClose();
 }
 
 //static
-size_t LL::ThreadPool::getConfiguredWidth(const std::string& name, size_t dft)
+size_t LL::ThreadPoolBase::getConfiguredWidth(const std::string& name, size_t dft)
 {
     LLSD poolSizes;
     try
@@ -132,7 +133,7 @@ size_t LL::ThreadPool::getConfiguredWidth(const std::string& name, size_t dft)
 }
 
 //static
-size_t LL::ThreadPool::getWidth(const std::string& name, size_t dft)
+size_t LL::ThreadPoolBase::getWidth(const std::string& name, size_t dft)
 {
     auto instance{ getInstance(name) };
     if (instance)
-- 
cgit v1.2.3