From 38d6d37f2d982fa959e9e8a4a3f7e1ccfad7b5d4 Mon Sep 17 00:00:00 2001 From: Jacek Antonelli Date: Fri, 15 Aug 2008 23:44:46 -0500 Subject: Second Life viewer sources 1.13.2.12 --- linden/indra/llcommon/llworkerthread.h | 187 +++++++++++++++++++++++++++++++++ 1 file changed, 187 insertions(+) create mode 100644 linden/indra/llcommon/llworkerthread.h (limited to 'linden/indra/llcommon/llworkerthread.h') diff --git a/linden/indra/llcommon/llworkerthread.h b/linden/indra/llcommon/llworkerthread.h new file mode 100644 index 0000000..f01e67b --- /dev/null +++ b/linden/indra/llcommon/llworkerthread.h @@ -0,0 +1,187 @@ +/** + * @file llworkerthread.h + * + * 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_LLWORKERTHREAD_H +#define LL_LLWORKERTHREAD_H + +#include +#include +#include +#include + +#include "llqueuedthread.h" + +#define USE_FRAME_CALLBACK_MANAGER 0 + +//============================================================================ + +class LLWorkerClass; + +//============================================================================ +// Note: ~LLWorkerThread is O(N) N=# of worker threads, assumed to be small +// It is assumed that LLWorkerThreads are rarely created/destroyed. + +class LLWorkerThread : public LLQueuedThread +{ +public: + class Request : public LLQueuedThread::QueuedRequest + { + protected: + ~Request() {}; // use deleteRequest() + + public: + Request(handle_t handle, U32 priority, LLWorkerClass* workerclass, S32 param); + + S32 getParam() + { + return mParam; + } + LLWorkerClass* getWorkerClass() + { + return mWorkerClass; + } + + /*virtual*/ void deleteRequest(); + + private: + LLWorkerClass* mWorkerClass; + S32 mParam; + }; + +public: + LLWorkerThread(bool threaded = true, bool runalways = true); + ~LLWorkerThread(); + +protected: + /*virtual*/ bool processRequest(QueuedRequest* req); + +public: + handle_t add(LLWorkerClass* workerclass, S32 param, U32 priority = PRIORITY_NORMAL); + + static void initClass(bool local_is_threaded = true, bool local_run_always = true); // Setup sLocal + static S32 updateClass(U32 ms_elapsed); + static S32 getAllPending(); + static void pauseAll(); + static void waitOnAllPending(); + static void cleanupClass(); // Delete sLocal + +public: + static LLWorkerThread* sLocal; // Default worker thread + static std::set sThreadList; // array of threads (includes sLocal) +}; + +//============================================================================ + +// This is a base class which any class with worker functions should derive from. +// Example Usage: +// LLMyWorkerClass* foo = new LLMyWorkerClass(); +// foo->fetchData(); // calls addWork() +// while(1) // main loop +// { +// if (foo->hasData()) // calls checkWork() +// foo->processData(); +// } +// +// WorkerClasses only have one set of work functions. If they need to do multiple +// background tasks, use 'param' to switch amnong them. +// Only one background task can be active at a time (per instance). +// i.e. don't call addWork() if haveWork() returns true + +class LLWorkerClass +{ +public: + typedef LLWorkerThread::handle_t handle_t; + enum FLAGS + { + WCF_WORKING = 0x01, + WCF_ABORT_REQUESTED = 0x80 + }; + +public: + LLWorkerClass(LLWorkerThread* workerthread, const std::string& name); + virtual ~LLWorkerClass(); + + // pure virtual, called from WORKER THREAD, returns TRUE if done + virtual bool doWork(S32 param)=0; // Called from LLWorkerThread::processRequest() + + // called from WORKER THREAD + void setWorking(bool working) { working ? setFlags(WCF_WORKING) : clearFlags(WCF_WORKING); } + + bool isWorking() { return getFlags(WCF_WORKING); } + bool wasAborted() { return getFlags(WCF_ABORT_REQUESTED); } + + const std::string& getName() const { return mWorkerClassName; } + +protected: + // Call from doWork only to avoid eating up cpu time. + // Returns true if work has been aborted + // yields the current thread and calls mWorkerThread->checkPause() + bool yield(); + + void setWorkerThread(LLWorkerThread* workerthread); + + // addWork(): calls startWork, adds doWork() to queue + void addWork(S32 param, U32 priority = LLWorkerThread::PRIORITY_NORMAL); + + // abortWork(): requests that work be aborted + void abortWork(); + + // checkWork(): if doWork is complete or aborted, call endWork() and return true + bool checkWork(); + + // haveWork(): return true if mWorkHandle != null + bool haveWork() { return mWorkHandle != LLWorkerThread::nullHandle(); } + + // killWork(): aborts work and waits for the abort to process + void killWork(); + + // setPriority(): changes the priority of a request + void setPriority(U32 priority); + +private: + void setFlags(U32 flags) { mWorkFlags = mWorkFlags | flags; } + void clearFlags(U32 flags) { mWorkFlags = mWorkFlags & ~flags; } + U32 getFlags() { return mWorkFlags; } + bool getFlags(U32 flags) { return mWorkFlags & flags ? true : false; } + +private: + // pure virtuals + virtual void startWork(S32 param)=0; // called from addWork() (MAIN THREAD) + virtual void endWork(S32 param, bool aborted)=0; // called from doWork() (MAIN THREAD) + +protected: + LLWorkerThread* mWorkerThread; + std::string mWorkerClassName; + handle_t mWorkHandle; + +private: + LLAtomicU32 mWorkFlags; +}; + +//============================================================================ + + +#endif // LL_LLWORKERTHREAD_H -- cgit v1.1