From 81a913616c70abdfaf25f4274530006b932dc1a0 Mon Sep 17 00:00:00 2001 From: marauder2k7 Date: Sun, 12 May 2024 21:59:18 +0100 Subject: [PATCH] revert ThreadPool rename revert ThreadPool rename, resources ThreadPool class is already nested in namespace VHACD --- Engine/source/app/mainLoop.cpp | 8 +-- Engine/source/gfx/bitmap/imageUtils.cpp | 4 +- Engine/source/gfx/video/theoraTexture.cpp | 2 +- Engine/source/gfx/video/theoraTexture.h | 2 +- .../platform/async/asyncBufferedStream.h | 10 +-- .../source/platform/async/asyncPacketStream.h | 6 +- Engine/source/platform/platformNetAsync.cpp | 8 +-- Engine/source/platform/threads/threadPool.cpp | 62 +++++++++---------- Engine/source/platform/threads/threadPool.h | 18 +++--- .../platform/threads/threadPoolAsyncIO.h | 2 +- Engine/source/sfx/sfxInternal.h | 6 +- Engine/source/testing/threadPoolTest.cpp | 10 +-- 12 files changed, 69 insertions(+), 69 deletions(-) diff --git a/Engine/source/app/mainLoop.cpp b/Engine/source/app/mainLoop.cpp index c2b037252..2acb64845 100644 --- a/Engine/source/app/mainLoop.cpp +++ b/Engine/source/app/mainLoop.cpp @@ -262,7 +262,7 @@ void StandardMainLoop::init() RedBook::init(); Platform::initConsole(); - TorqueThreadPool::GlobalThreadPool::createSingleton(); + ThreadPool::GlobalThreadPool::createSingleton(); // Set engineAPI initialized to true engineAPI::gIsInitialized = true; @@ -293,7 +293,7 @@ void StandardMainLoop::init() Con::setVariable("TorqueScriptFileExtension", TORQUE_SCRIPT_EXTENSION); - Con::addVariable( "_forceAllMainThread", TypeBool, &TorqueThreadPool::getForceAllMainThread(), "Force all work items to execute on main thread. turns this into a single-threaded system. Primarily useful to find whether malfunctions are caused by parallel execution or not.\n" + Con::addVariable( "_forceAllMainThread", TypeBool, &ThreadPool::getForceAllMainThread(), "Force all work items to execute on main thread. turns this into a single-threaded system. Primarily useful to find whether malfunctions are caused by parallel execution or not.\n" "@ingroup platform" ); #if defined( TORQUE_MINIDUMP ) && defined( TORQUE_RELEASE ) @@ -351,7 +351,7 @@ void StandardMainLoop::shutdown() EngineModuleManager::shutdownSystem(); - TorqueThreadPool::GlobalThreadPool::deleteSingleton(); + ThreadPool::GlobalThreadPool::deleteSingleton(); #ifdef TORQUE_ENABLE_VFS closeEmbeddedVFSArchive(); @@ -636,7 +636,7 @@ bool StandardMainLoop::doMainLoop() if(!Process::processEvents()) keepRunning = false; - TorqueThreadPool::processMainThreadWorkItems(); + ThreadPool::processMainThreadWorkItems(); Sampler::endFrame(); ConsoleValue::resetConversionBuffer(); PROFILE_END_NAMED(MainLoop); diff --git a/Engine/source/gfx/bitmap/imageUtils.cpp b/Engine/source/gfx/bitmap/imageUtils.cpp index 1b289d31d..3426eecd3 100644 --- a/Engine/source/gfx/bitmap/imageUtils.cpp +++ b/Engine/source/gfx/bitmap/imageUtils.cpp @@ -65,7 +65,7 @@ namespace ImageUtil } //Thread work job for compression - struct CompressJob : public TorqueThreadPool::WorkItem + struct CompressJob : public ThreadPool::WorkItem { S32 width; S32 height; @@ -124,7 +124,7 @@ namespace ImageUtil srcDDS->mFlags.set(DDSFile::CompressedData); //grab global thread pool - TorqueThreadPool* pThreadPool = &TorqueThreadPool::GLOBAL(); + ThreadPool* pThreadPool = &ThreadPool::GLOBAL(); if (cubemap) { diff --git a/Engine/source/gfx/video/theoraTexture.cpp b/Engine/source/gfx/video/theoraTexture.cpp index 3b1403a1b..83063e3be 100644 --- a/Engine/source/gfx/video/theoraTexture.cpp +++ b/Engine/source/gfx/video/theoraTexture.cpp @@ -336,7 +336,7 @@ void TheoraTexture::_onTextureEvent( GFXTexCallbackCode code ) { // Blast out work items and then release all texture locks. - TorqueThreadPool::GLOBAL().flushWorkItems(); + ThreadPool::GLOBAL().flushWorkItems(); mAsyncState->getFrameStream()->releaseTextureLocks(); // The Theora decoder does not implement seeking at the moment, diff --git a/Engine/source/gfx/video/theoraTexture.h b/Engine/source/gfx/video/theoraTexture.h index 899673ad4..8c0748068 100644 --- a/Engine/source/gfx/video/theoraTexture.h +++ b/Engine/source/gfx/video/theoraTexture.h @@ -177,7 +177,7 @@ class TheoraTexture : private IOutputStream< TheoraTextureFrame* >, /// FrameReadItem( AsyncBufferedInputStream< TheoraTextureFrame*, IInputStream< OggTheoraFrame* >* >* stream, - TorqueThreadPool::Context* context ); + ThreadPool::Context* context ); }; /// Stream filter that turns a stream of OggTheoraFrames into a buffered background stream of TheoraTextureFrame diff --git a/Engine/source/platform/async/asyncBufferedStream.h b/Engine/source/platform/async/asyncBufferedStream.h index 15e44a693..8c421c5c9 100644 --- a/Engine/source/platform/async/asyncBufferedStream.h +++ b/Engine/source/platform/async/asyncBufferedStream.h @@ -107,7 +107,7 @@ class AsyncBufferedInputStream : public IInputStreamFilter< T, Stream >, ElementList mBufferedElements; /// The thread pool to which read items are queued. - TorqueThreadPool* mThreadPool; + ThreadPool* mThreadPool; /// The thread context used for prioritizing read items in the pool. ThreadContext* mThreadContext; @@ -132,7 +132,7 @@ class AsyncBufferedInputStream : public IInputStreamFilter< T, Stream >, U32 numSourceElementsToRead = 0, U32 numReadAhead = DEFAULT_STREAM_LOOKAHEAD, bool isLooping = false, - TorqueThreadPool* pool = &TorqueThreadPool::GLOBAL(), + ThreadPool* pool = &ThreadPool::GLOBAL(), ThreadContext* context = ThreadContext::ROOT_CONTEXT() ); virtual ~AsyncBufferedInputStream(); @@ -162,7 +162,7 @@ AsyncBufferedInputStream< T, Stream >::AsyncBufferedInputStream U32 numSourceElementsToRead, U32 numReadAhead, bool isLooping, - TorqueThreadPool* threadPool, + ThreadPool* threadPool, ThreadContext* threadContext ) : Parent( stream ), mIsLooping( isLooping ), @@ -321,7 +321,7 @@ class AsyncBufferedReadItem : public ThreadWorkItem /// AsyncBufferedReadItem( const AsyncStreamRef& asyncStream, - TorqueThreadPool::Context* context = NULL + ThreadPool::Context* context = NULL ) : Parent( context ), mAsyncStream( asyncStream ), @@ -376,7 +376,7 @@ class AsyncSingleBufferedInputStream : public AsyncBufferedInputStream< T, Strea U32 numSourceElementsToRead = 0, U32 numReadAhead = Parent::DEFAULT_STREAM_LOOKAHEAD, bool isLooping = false, - TorqueThreadPool* pool = &TorqueThreadPool::GLOBAL(), + ThreadPool* pool = &ThreadPool::GLOBAL(), ThreadContext* context = ThreadContext::ROOT_CONTEXT() ) : Parent( stream, numSourceElementsToRead, diff --git a/Engine/source/platform/async/asyncPacketStream.h b/Engine/source/platform/async/asyncPacketStream.h index 517990a41..374118784 100644 --- a/Engine/source/platform/async/asyncPacketStream.h +++ b/Engine/source/platform/async/asyncPacketStream.h @@ -113,7 +113,7 @@ class AsyncPacketBufferedInputStream : public AsyncBufferedInputStream< Packet*, PacketReadItem( const ThreadSafeRef< AsyncPacketBufferedInputStream< Stream, Packet > >& asyncStream, PacketType* packet, U32 numElements, - TorqueThreadPool::Context* context = NULL ) + ThreadPool::Context* context = NULL ) : Parent( asyncStream->getSourceStream(), numElements, 0, *packet, false, 0, context ), mAsyncStream( asyncStream ), mPacket( packet ) {} @@ -227,7 +227,7 @@ class AsyncPacketBufferedInputStream : public AsyncBufferedInputStream< Packet*, U32 numSourceElementsToRead = 0, U32 numReadAhead = Parent::DEFAULT_STREAM_LOOKAHEAD, bool isLooping = false, - TorqueThreadPool* pool = &TorqueThreadPool::GLOBAL(), + ThreadPool* pool = &ThreadPool::GLOBAL(), ThreadContext* context = ThreadContext::ROOT_CONTEXT() ); /// @return the size of stream packets returned by this stream in number of elements. @@ -241,7 +241,7 @@ AsyncPacketBufferedInputStream< Stream, Packet >::AsyncPacketBufferedInputStream U32 numSourceElementsToRead, U32 numReadAhead, bool isLooping, - TorqueThreadPool* threadPool, + ThreadPool* threadPool, ThreadContext* threadContext ) : Parent( stream, numSourceElementsToRead, numReadAhead, isLooping, threadPool, threadContext ), mPacketSize( packetSize ), diff --git a/Engine/source/platform/platformNetAsync.cpp b/Engine/source/platform/platformNetAsync.cpp index 57873a312..1a2a33df2 100644 --- a/Engine/source/platform/platformNetAsync.cpp +++ b/Engine/source/platform/platformNetAsync.cpp @@ -65,11 +65,11 @@ struct NetAsync::NameLookupRequest /// Work item issued to the thread pool for each lookup request. -struct NetAsync::NameLookupWorkItem : public TorqueThreadPool::WorkItem +struct NetAsync::NameLookupWorkItem : public ThreadPool::WorkItem { - typedef TorqueThreadPool::WorkItem Parent; + typedef ThreadPool::WorkItem Parent; - NameLookupWorkItem( NameLookupRequest& request, TorqueThreadPool::Context* context = 0 ) + NameLookupWorkItem( NameLookupRequest& request, ThreadPool::Context* context = 0 ) : Parent( context ), mRequest( request ) { @@ -133,7 +133,7 @@ void NetAsync::queueLookup(const char* remoteAddr, NetSocket socket) dStrncpy(lookupRequest.remoteAddr, remoteAddr, sizeof(lookupRequest.remoteAddr)); ThreadSafeRef< NameLookupWorkItem > workItem( new NameLookupWorkItem( lookupRequest ) ); - TorqueThreadPool::GLOBAL().queueWorkItem( workItem ); + ThreadPool::GLOBAL().queueWorkItem( workItem ); } bool NetAsync::checkLookup(NetSocket socket, void* out_h_addr, diff --git a/Engine/source/platform/threads/threadPool.cpp b/Engine/source/platform/threads/threadPool.cpp index a3e4f9266..42f262726 100644 --- a/Engine/source/platform/threads/threadPool.cpp +++ b/Engine/source/platform/threads/threadPool.cpp @@ -34,11 +34,11 @@ // ThreadPool::Context. //============================================================================= -TorqueThreadPool::Context TorqueThreadPool::Context::smRootContext( "ROOT", NULL, 1.0 ); +ThreadPool::Context ThreadPool::Context::smRootContext( "ROOT", NULL, 1.0 ); //-------------------------------------------------------------------------- -TorqueThreadPool::Context::Context( const char* name, TorqueThreadPool::Context* parent, F32 priorityBias ) +ThreadPool::Context::Context( const char* name, ThreadPool::Context* parent, F32 priorityBias ) : mParent( parent ), mName( name ), mChildren( 0 ), @@ -55,7 +55,7 @@ TorqueThreadPool::Context::Context( const char* name, TorqueThreadPool::Context* //-------------------------------------------------------------------------- -TorqueThreadPool::Context::~Context() +ThreadPool::Context::~Context() { if( mParent ) for( Context* context = mParent->mChildren, *prev = 0; context != 0; prev = context, context = context->mSibling ) @@ -70,7 +70,7 @@ TorqueThreadPool::Context::~Context() //-------------------------------------------------------------------------- -TorqueThreadPool::Context* TorqueThreadPool::Context::getChild( const char* name ) +ThreadPool::Context* ThreadPool::Context::getChild( const char* name ) { for( Context* child = getChildren(); child != 0; child = child->getSibling() ) if( dStricmp( child->getName(), name ) == 0 ) @@ -80,7 +80,7 @@ TorqueThreadPool::Context* TorqueThreadPool::Context::getChild( const char* name //-------------------------------------------------------------------------- -F32 TorqueThreadPool::Context::getAccumulatedPriorityBias() +F32 ThreadPool::Context::getAccumulatedPriorityBias() { if( !mAccumulatedPriorityBias ) updateAccumulatedPriorityBiases(); @@ -89,7 +89,7 @@ F32 TorqueThreadPool::Context::getAccumulatedPriorityBias() //-------------------------------------------------------------------------- -void TorqueThreadPool::Context::setPriorityBias( F32 value ) +void ThreadPool::Context::setPriorityBias( F32 value ) { mPriorityBias = value; mAccumulatedPriorityBias = 0.0; @@ -97,7 +97,7 @@ void TorqueThreadPool::Context::setPriorityBias( F32 value ) //-------------------------------------------------------------------------- -void TorqueThreadPool::Context::updateAccumulatedPriorityBiases() +void ThreadPool::Context::updateAccumulatedPriorityBiases() { // Update our own priority bias. @@ -117,7 +117,7 @@ void TorqueThreadPool::Context::updateAccumulatedPriorityBiases() //-------------------------------------------------------------------------- -void TorqueThreadPool::WorkItem::process() +void ThreadPool::WorkItem::process() { execute(); mExecuted = true; @@ -125,14 +125,14 @@ void TorqueThreadPool::WorkItem::process() //-------------------------------------------------------------------------- -bool TorqueThreadPool::WorkItem::isCancellationRequested() +bool ThreadPool::WorkItem::isCancellationRequested() { return false; } //-------------------------------------------------------------------------- -bool TorqueThreadPool::WorkItem::cancellationPoint() +bool ThreadPool::WorkItem::cancellationPoint() { if( isCancellationRequested() ) { @@ -145,7 +145,7 @@ bool TorqueThreadPool::WorkItem::cancellationPoint() //-------------------------------------------------------------------------- -F32 TorqueThreadPool::WorkItem::getPriority() +F32 ThreadPool::WorkItem::getPriority() { return 1.0; } @@ -160,7 +160,7 @@ F32 TorqueThreadPool::WorkItem::getPriority() /// @see ThreadSafePriorityQueueWithUpdate /// @see ThreadPool::WorkItem /// -struct TorqueThreadPool::WorkItemWrapper : public ThreadSafeRef< WorkItem > +struct ThreadPool::WorkItemWrapper : public ThreadSafeRef< WorkItem > { typedef ThreadSafeRef< WorkItem > Parent; @@ -172,7 +172,7 @@ struct TorqueThreadPool::WorkItemWrapper : public ThreadSafeRef< WorkItem > F32 getPriority(); }; -inline bool TorqueThreadPool::WorkItemWrapper::isAlive() +inline bool ThreadPool::WorkItemWrapper::isAlive() { WorkItem* item = ptr(); if( !item ) @@ -186,7 +186,7 @@ inline bool TorqueThreadPool::WorkItemWrapper::isAlive() return true; } -inline F32 TorqueThreadPool::WorkItemWrapper::getPriority() +inline F32 ThreadPool::WorkItemWrapper::getPriority() { WorkItem* item = ptr(); AssertFatal( item != 0, "ThreadPool::WorkItemWrapper::getPriority - called on dead item" ); @@ -201,20 +201,20 @@ inline F32 TorqueThreadPool::WorkItemWrapper::getPriority() /// /// -struct TorqueThreadPool::WorkerThread : public Thread +struct ThreadPool::WorkerThread : public Thread { - WorkerThread( TorqueThreadPool* pool, U32 index ); + WorkerThread( ThreadPool* pool, U32 index ); WorkerThread* getNext(); void run( void* arg = 0 ) override; private: U32 mIndex; - TorqueThreadPool* mPool; + ThreadPool* mPool; WorkerThread* mNext; }; -TorqueThreadPool::WorkerThread::WorkerThread( TorqueThreadPool* pool, U32 index ) +ThreadPool::WorkerThread::WorkerThread( ThreadPool* pool, U32 index ) : mIndex( index ), mPool( pool ) { @@ -224,12 +224,12 @@ TorqueThreadPool::WorkerThread::WorkerThread( TorqueThreadPool* pool, U32 index pool->mThreads = this; } -inline TorqueThreadPool::WorkerThread* TorqueThreadPool::WorkerThread::getNext() +inline ThreadPool::WorkerThread* ThreadPool::WorkerThread::getNext() { return mNext; } -void TorqueThreadPool::WorkerThread::run( void* arg ) +void ThreadPool::WorkerThread::run( void* arg ) { #ifdef TORQUE_DEBUG { @@ -300,13 +300,13 @@ void TorqueThreadPool::WorkerThread::run( void* arg ) // ThreadPool. //============================================================================= -bool TorqueThreadPool::smForceAllMainThread; -U32 TorqueThreadPool::smMainThreadTimeMS; -TorqueThreadPool::QueueType TorqueThreadPool::smMainThreadQueue; +bool ThreadPool::smForceAllMainThread; +U32 ThreadPool::smMainThreadTimeMS; +ThreadPool::QueueType ThreadPool::smMainThreadQueue; //-------------------------------------------------------------------------- -TorqueThreadPool::TorqueThreadPool( const char* name, U32 numThreads ) +ThreadPool::ThreadPool( const char* name, U32 numThreads ) : mName( name ), mNumThreads( numThreads ), mNumThreadsAwake( 0 ), @@ -347,14 +347,14 @@ TorqueThreadPool::TorqueThreadPool( const char* name, U32 numThreads ) //-------------------------------------------------------------------------- -TorqueThreadPool::~TorqueThreadPool() +ThreadPool::~ThreadPool() { shutdown(); } //-------------------------------------------------------------------------- -void TorqueThreadPool::shutdown() +void ThreadPool::shutdown() { const U32 numThreads = mNumThreads; @@ -387,7 +387,7 @@ void TorqueThreadPool::shutdown() //-------------------------------------------------------------------------- -void TorqueThreadPool::queueWorkItem( WorkItem* item ) +void ThreadPool::queueWorkItem( WorkItem* item ) { bool executeRightAway = ( getForceAllMainThread() ); #ifdef DEBUG_SPEW @@ -410,7 +410,7 @@ void TorqueThreadPool::queueWorkItem( WorkItem* item ) //-------------------------------------------------------------------------- -void TorqueThreadPool::flushWorkItems( S32 timeOut ) +void ThreadPool::flushWorkItems( S32 timeOut ) { AssertFatal( mNumThreads, "ThreadPool::flushWorkItems() - no worker threads in pool" ); @@ -432,7 +432,7 @@ void TorqueThreadPool::flushWorkItems( S32 timeOut ) } } -void TorqueThreadPool::waitForAllItems( S32 timeOut ) +void ThreadPool::waitForAllItems( S32 timeOut ) { U32 endTime = 0; if( timeOut != -1 ) @@ -454,14 +454,14 @@ void TorqueThreadPool::waitForAllItems( S32 timeOut ) //-------------------------------------------------------------------------- -void TorqueThreadPool::queueWorkItemOnMainThread( WorkItem* item ) +void ThreadPool::queueWorkItemOnMainThread( WorkItem* item ) { smMainThreadQueue.insert( item->getPriority(), item ); } //-------------------------------------------------------------------------- -void TorqueThreadPool::processMainThreadWorkItems() +void ThreadPool::processMainThreadWorkItems() { AssertFatal( ThreadManager::isMainThread(), "ThreadPool::processMainThreadWorkItems - this function must only be called on the main thread" ); diff --git a/Engine/source/platform/threads/threadPool.h b/Engine/source/platform/threads/threadPool.h index 59abc8620..5fb8cc60b 100644 --- a/Engine/source/platform/threads/threadPool.h +++ b/Engine/source/platform/threads/threadPool.h @@ -70,7 +70,7 @@ /// automatically being released once the last concurrent work item has been /// processed or discarded. /// -class TorqueThreadPool +class ThreadPool { public: @@ -298,9 +298,9 @@ class TorqueThreadPool /// will be based on the number of CPU cores available. /// /// @param numThreads Number of threads to create or zero for default. - TorqueThreadPool( const char* name, U32 numThreads = 0 ); + ThreadPool( const char* name, U32 numThreads = 0 ); - ~TorqueThreadPool(); + ~ThreadPool(); /// Manually shutdown threads outside of static destructors. void shutdown(); @@ -397,16 +397,16 @@ class TorqueThreadPool } /// Return the global thread pool singleton. - static TorqueThreadPool& GLOBAL(); + static ThreadPool& GLOBAL(); }; -typedef TorqueThreadPool::Context ThreadContext; -typedef TorqueThreadPool::WorkItem ThreadWorkItem; +typedef ThreadPool::Context ThreadContext; +typedef ThreadPool::WorkItem ThreadWorkItem; -struct TorqueThreadPool::GlobalThreadPool : public TorqueThreadPool, public ManagedSingleton< GlobalThreadPool > +struct ThreadPool::GlobalThreadPool : public ThreadPool, public ManagedSingleton< GlobalThreadPool > { - typedef TorqueThreadPool Parent; + typedef ThreadPool Parent; GlobalThreadPool() : Parent( "GLOBAL" ) {} @@ -415,7 +415,7 @@ struct TorqueThreadPool::GlobalThreadPool : public TorqueThreadPool, public Mana static const char* getSingletonName() { return "GlobalThreadPool"; } }; -inline TorqueThreadPool& TorqueThreadPool::GLOBAL() +inline ThreadPool& ThreadPool::GLOBAL() { return *( GlobalThreadPool::instance() ); } diff --git a/Engine/source/platform/threads/threadPoolAsyncIO.h b/Engine/source/platform/threads/threadPoolAsyncIO.h index 7e78f1752..35738d091 100644 --- a/Engine/source/platform/threads/threadPoolAsyncIO.h +++ b/Engine/source/platform/threads/threadPoolAsyncIO.h @@ -54,7 +54,7 @@ /// /// @param T Type of elements being streamed. template< typename T, class Stream > -class AsyncIOItem : public TorqueThreadPool::WorkItem +class AsyncIOItem : public ThreadPool::WorkItem { public: diff --git a/Engine/source/sfx/sfxInternal.h b/Engine/source/sfx/sfxInternal.h index e5109727a..7d2c49df2 100644 --- a/Engine/source/sfx/sfxInternal.h +++ b/Engine/source/sfx/sfxInternal.h @@ -358,11 +358,11 @@ enum /// @note Don't use this directly but rather use THREAD_POOL() instead. /// This way, the sound code may be easily switched to using a common /// pool later on. -class SFXThreadPool : public TorqueThreadPool, public ManagedSingleton< SFXThreadPool > +class SFXThreadPool : public ThreadPool, public ManagedSingleton< SFXThreadPool > { public: - typedef TorqueThreadPool Parent; + typedef ThreadPool Parent; /// Create a ThreadPool called "SFX" with two threads. SFXThreadPool() @@ -399,7 +399,7 @@ extern ThreadSafeRef< SFXBufferProcessList > gBufferUpdateList; extern ThreadSafeDeque< SFXBuffer* > gDeadBufferList; /// Return the thread pool used for SFX work. -inline TorqueThreadPool& THREAD_POOL() +inline ThreadPool& THREAD_POOL() { return *( SFXThreadPool::instance() ); } diff --git a/Engine/source/testing/threadPoolTest.cpp b/Engine/source/testing/threadPoolTest.cpp index 228b7ba61..cdd39c50b 100644 --- a/Engine/source/testing/threadPoolTest.cpp +++ b/Engine/source/testing/threadPoolTest.cpp @@ -30,7 +30,7 @@ FIXTURE(ThreadPool) public: // Represents a single unit of work. In this test we just set an element in // a result vector. - struct TestItem : public TorqueThreadPool::WorkItem + struct TestItem : public ThreadPool::WorkItem { U32 mIndex; Vector& mResults; @@ -46,7 +46,7 @@ public: // A worker that delays for some time. We'll use this to test the ThreadPool's // synchronous and asynchronous operations. - struct DelayItem : public TorqueThreadPool::WorkItem + struct DelayItem : public ThreadPool::WorkItem { U32 ms; DelayItem(U32 _ms) : ms(_ms) {} @@ -69,7 +69,7 @@ TEST_FIX(ThreadPool, BasicAPI) results[i] = U32(-1); // Launch the work items. - TorqueThreadPool* pool = &TorqueThreadPool::GLOBAL(); + ThreadPool* pool = &ThreadPool::GLOBAL(); for (U32 i = 0; i < numItems; i++) { ThreadSafeRef item(new TestItem(i, results)); @@ -89,7 +89,7 @@ TEST_FIX(ThreadPool, Asynchronous) const U32 delay = 500; //ms // Launch a single delaying work item. - TorqueThreadPool* pool = &TorqueThreadPool::GLOBAL(); + ThreadPool* pool = &ThreadPool::GLOBAL(); ThreadSafeRef item(new DelayItem(delay)); pool->queueWorkItem(item); @@ -107,7 +107,7 @@ TEST_FIX(ThreadPool, Synchronous) const U32 delay = 500; //ms // Launch a single delaying work item. - TorqueThreadPool* pool = &TorqueThreadPool::GLOBAL(); + ThreadPool* pool = &ThreadPool::GLOBAL(); ThreadSafeRef item(new DelayItem(delay)); pool->queueWorkItem(item);