OgreWorkQueue.h

Go to the documentation of this file.
00001 /*
00002 -----------------------------------------------------------------------------
00003 This source file is part of OGRE
00004 (Object-oriented Graphics Rendering Engine)
00005 For the latest info, see http://www.ogre3d.org/
00006 
00007 Copyright (c) 2000-2009 Torus Knot Software Ltd
00008 
00009 Permission is hereby granted, free of charge, to any person obtaining a copy
00010 of this software and associated documentation files (the "Software"), to deal
00011 in the Software without restriction, including without limitation the rights
00012 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
00013 copies of the Software, and to permit persons to whom the Software is
00014 furnished to do so, subject to the following conditions:
00015 
00016 The above copyright notice and this permission notice shall be included in
00017 all copies or substantial portions of the Software.
00018 
00019 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
00020 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
00021 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
00022 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
00023 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00024 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
00025 THE SOFTWARE.
00026 -----------------------------------------------------------------------------
00027 */
00028 #ifndef __OgreWorkQueue_H__
00029 #define __OgreWorkQueue_H__
00030 
00031 #include "OgrePrerequisites.h"
00032 #include "OgreAtomicWrappers.h"
00033 #include "OgreAny.h"
00034 
00035 namespace Ogre
00036 {
00068     class _OgreExport WorkQueue : public UtilityAlloc
00069     {
00070     protected:
00071         typedef std::map<String, uint16> ChannelMap;
00072         ChannelMap mChannelMap;
00073         uint16 mNextChannel;
00074         OGRE_MUTEX(mChannelMapMutex)
00075     public:
00077         typedef unsigned long long int RequestID;
00078 
00081         class _OgreExport Request : public UtilityAlloc
00082         {
00083             friend class WorkQueue;
00084         protected:
00086             uint16 mChannel;
00088             uint16 mType;
00090             Any mData;
00092             uint8 mRetryCount;
00094             RequestID mID;
00096             mutable bool mAborted;
00097 
00098         public:
00100             Request(uint16 channel, uint16 rtype, const Any& rData, uint8 retry, RequestID rid);
00101             ~Request();
00103             void abortRequest() const { mAborted = true; }
00105             uint16 getChannel() const { return mChannel; }
00107             uint16 getType() const { return mType; }
00109             const Any& getData() const { return mData; }
00111             uint8 getRetryCount() const { return mRetryCount; }
00113             RequestID getID() const { return mID; }
00115             bool getAborted() const { return mAborted; }
00116         };
00117 
00120         struct _OgreExport Response : public UtilityAlloc
00121         {
00123             const Request* mRequest;
00125             bool mSuccess;
00127             String mMessages;
00129             Any mData;
00130 
00131         public:
00132             Response(const Request* rq, bool success, const Any& data, const String& msg = StringUtil::BLANK);
00133             ~Response();
00135             const Request* getRequest() const { return mRequest; }
00137             bool succeeded() const { return mSuccess; }
00139             const String& getMessages() const { return mMessages; }
00141             const Any& getData() const { return mData; }
00143             void abortRequest() { mRequest->abortRequest(); mData.destroy(); }
00144         };
00145 
00159         class _OgreExport RequestHandler
00160         {
00161         public:
00162             RequestHandler() {}
00163             virtual ~RequestHandler() {}
00164 
00171             virtual bool canHandleRequest(const Request* req, const WorkQueue* srcQ) 
00172             { (void)srcQ; return !req->getAborted(); }
00173 
00184             virtual Response* handleRequest(const Request* req, const WorkQueue* srcQ) = 0;
00185         };
00186 
00194         class _OgreExport ResponseHandler
00195         {
00196         public:
00197             ResponseHandler() {}
00198             virtual ~ResponseHandler() {}
00199 
00206             virtual bool canHandleResponse(const Response* res, const WorkQueue* srcQ) 
00207             { (void)srcQ; return !res->getRequest()->getAborted(); }
00208 
00216             virtual void handleResponse(const Response* res, const WorkQueue* srcQ) = 0;
00217         };
00218 
00219         WorkQueue() : mNextChannel(0) {}
00220         virtual ~WorkQueue() {}
00221 
00226         virtual void startup(bool forceRestart = true) = 0;
00236         virtual void addRequestHandler(uint16 channel, RequestHandler* rh) = 0;
00238         virtual void removeRequestHandler(uint16 channel, RequestHandler* rh) = 0;
00239 
00249         virtual void addResponseHandler(uint16 channel, ResponseHandler* rh) = 0;
00251         virtual void removeResponseHandler(uint16 channel, ResponseHandler* rh) = 0;
00252 
00265         virtual RequestID addRequest(uint16 channel, uint16 requestType, const Any& rData, uint8 retryCount = 0, 
00266             bool forceSynchronous = false) = 0;
00267 
00273         virtual void abortRequest(RequestID id) = 0;
00274 
00280         virtual void abortRequestsByChannel(uint16 channel) = 0;
00281 
00286         virtual void abortAllRequests() = 0;
00287         
00293         virtual void setPaused(bool pause) = 0;
00295         virtual bool isPaused() const = 0;
00296 
00301         virtual void setRequestsAccepted(bool accept) = 0;
00303         virtual bool getRequestsAccepted() const = 0;
00304 
00313         virtual void processResponses() = 0; 
00314 
00318         virtual unsigned long getResponseProcessingTimeLimit() const = 0;
00319 
00325         virtual void setResponseProcessingTimeLimit(unsigned long ms) = 0;
00326 
00329         virtual void shutdown() = 0;
00330 
00338         virtual uint16 getChannel(const String& channelName);
00339 
00340     };
00341 
00344     class _OgreExport DefaultWorkQueueBase : public WorkQueue
00345     {
00346     public:
00347 
00352         DefaultWorkQueueBase(const String& name = StringUtil::BLANK);
00353         virtual ~DefaultWorkQueueBase();
00355         const String& getName() const;
00359         virtual size_t getWorkerThreadCount() const;
00360 
00366         virtual void setWorkerThreadCount(size_t c);
00367 
00377         virtual bool getWorkersCanAccessRenderSystem() const;
00378 
00379 
00391         virtual void setWorkersCanAccessRenderSystem(bool access);
00392 
00400         virtual void _processNextRequest();
00401 
00403         virtual void _threadMain() = 0;
00404 
00406         virtual bool isShuttingDown() const { return mShuttingDown; }
00407 
00409         virtual void addRequestHandler(uint16 channel, RequestHandler* rh);
00411         virtual void removeRequestHandler(uint16 channel, RequestHandler* rh);
00413         virtual void addResponseHandler(uint16 channel, ResponseHandler* rh);
00415         virtual void removeResponseHandler(uint16 channel, ResponseHandler* rh);
00416 
00418         virtual RequestID addRequest(uint16 channel, uint16 requestType, const Any& rData, uint8 retryCount = 0, 
00419             bool forceSynchronous = false);
00421         virtual void abortRequest(RequestID id);
00423         virtual void abortRequestsByChannel(uint16 channel);
00425         virtual void abortAllRequests();
00427         virtual void setPaused(bool pause);
00429         virtual bool isPaused() const;
00431         virtual void setRequestsAccepted(bool accept);
00433         virtual bool getRequestsAccepted() const;
00435         virtual void processResponses(); 
00437         virtual unsigned long getResponseProcessingTimeLimit() const { return mResposeTimeLimitMS; }
00439         virtual void setResponseProcessingTimeLimit(unsigned long ms) { mResposeTimeLimitMS = ms; }
00440     protected:
00441         String mName;
00442         size_t mWorkerThreadCount;
00443         bool mWorkerRenderSystemAccess;
00444         bool mIsRunning;
00445         unsigned long mResposeTimeLimitMS;
00446 
00447         typedef deque<Request*>::type RequestQueue;
00448         typedef deque<Response*>::type ResponseQueue;
00449         RequestQueue mRequestQueue;
00450         RequestQueue mProcessQueue;
00451         ResponseQueue mResponseQueue;
00452 
00454         struct WorkerFunc OGRE_THREAD_WORKER_INHERIT
00455         {
00456             DefaultWorkQueueBase* mQueue;
00457 
00458             WorkerFunc(DefaultWorkQueueBase* q) 
00459                 : mQueue(q) {}
00460 
00461             void operator()();
00462 
00463             void run();
00464         };
00465         WorkerFunc* mWorkerFunc;
00466 
00467         typedef list<RequestHandler*>::type RequestHandlerList;
00468         typedef list<ResponseHandler*>::type ResponseHandlerList;
00469         typedef map<uint16, RequestHandlerList>::type RequestHandlerListByChannel;
00470         typedef map<uint16, ResponseHandlerList>::type ResponseHandlerListByChannel;
00471 
00472         RequestHandlerListByChannel mRequestHandlers;
00473         ResponseHandlerListByChannel mResponseHandlers;
00474         RequestID mRequestCount;
00475         bool mPaused;
00476         bool mAcceptRequests;
00477         bool mShuttingDown;
00478 
00479         OGRE_MUTEX(mRequestMutex)
00480         OGRE_MUTEX(mProcessMutex)
00481         OGRE_MUTEX(mResponseMutex)
00482         OGRE_RW_MUTEX(mRequestHandlerMutex);
00483 
00484 
00485         void processRequestResponse(Request* r, bool synchronous);
00486         Response* processRequest(Request* r);
00487         void processResponse(Response* r);
00489         virtual void notifyWorkers() = 0;
00491         void addRequestWithRID(RequestID rid, uint16 channel, uint16 requestType, const Any& rData, uint8 retryCount);
00492 
00493     };
00494 
00495 
00496 
00497 
00498 
00502 }
00503 
00504 
00505 #endif
00506 

Copyright © 2008 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Thu Dec 31 16:27:15 2009