//////////////////////////////////////////////////////////////////////////////// /// @brief dispatcher queue /// /// @file /// /// DISCLAIMER /// /// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany /// /// Licensed under the Apache License, Version 2.0 (the "License"); /// you may not use this file except in compliance with the License. /// You may obtain a copy of the License at /// /// http://www.apache.org/licenses/LICENSE-2.0 /// /// Unless required by applicable law or agreed to in writing, software /// distributed under the License is distributed on an "AS IS" BASIS, /// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. /// See the License for the specific language governing permissions and /// limitations under the License. /// /// Copyright holder is triAGENS GmbH, Cologne, Germany /// /// @author Dr. Frank Celler /// @author Martin Schoenert /// @author Copyright 2009-2014, triAGENS GmbH, Cologne, Germany //////////////////////////////////////////////////////////////////////////////// #ifndef TRIAGENS_DISPATCHER_DISPATCHER_QUEUE_H #define TRIAGENS_DISPATCHER_DISPATCHER_QUEUE_H 1 #include "Basics/Common.h" #include "Basics/ConditionVariable.h" #include "Dispatcher/Dispatcher.h" // ----------------------------------------------------------------------------- // --SECTION-- forward declarations // ----------------------------------------------------------------------------- namespace triagens { namespace rest { class DispatcherThread; class Job; // ----------------------------------------------------------------------------- // --SECTION-- class DispatcherQueue // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief dispatcher queue //////////////////////////////////////////////////////////////////////////////// class DispatcherQueue { friend class Dispatcher; friend class DispatcherThread; private: DispatcherQueue (DispatcherQueue const&); DispatcherQueue& operator= (DispatcherQueue const&); // ----------------------------------------------------------------------------- // --SECTION-- constructors and destructors // ----------------------------------------------------------------------------- public: //////////////////////////////////////////////////////////////////////////////// /// @brief constructs a new dispatcher queue //////////////////////////////////////////////////////////////////////////////// DispatcherQueue (Scheduler*, Dispatcher*, std::string const&, Dispatcher::newDispatcherThread_fptr, size_t, size_t); ///////////////////////////////////////////////////////////////////////////// /// @brief destructor ///////////////////////////////////////////////////////////////////////////// ~DispatcherQueue (); // ----------------------------------------------------------------------------- // --SECTION-- public methods // ----------------------------------------------------------------------------- public: //////////////////////////////////////////////////////////////////////////////// /// @brief adds a job //////////////////////////////////////////////////////////////////////////////// bool addJob (Job*); //////////////////////////////////////////////////////////////////////////////// /// @brief tries to cancel a job //////////////////////////////////////////////////////////////////////////////// bool cancelJob (uint64_t); //////////////////////////////////////////////////////////////////////////////// /// @brief downgrades the thread to special //////////////////////////////////////////////////////////////////////////////// void specializeThread (DispatcherThread*); //////////////////////////////////////////////////////////////////////////////// /// @brief starts a queue //////////////////////////////////////////////////////////////////////////////// bool start (); //////////////////////////////////////////////////////////////////////////////// /// @brief begins the shutdown sequence the queue //////////////////////////////////////////////////////////////////////////////// void beginShutdown (); //////////////////////////////////////////////////////////////////////////////// /// @brief shut downs the queue //////////////////////////////////////////////////////////////////////////////// void shutdown (); //////////////////////////////////////////////////////////////////////////////// /// @brief checks if the dispatcher queues are up and running //////////////////////////////////////////////////////////////////////////////// bool isStarted (); //////////////////////////////////////////////////////////////////////////////// /// @brief is the queue still active //////////////////////////////////////////////////////////////////////////////// bool isRunning (); //////////////////////////////////////////////////////////////////////////////// /// @brief starts a new queue thread //////////////////////////////////////////////////////////////////////////////// bool startQueueThread (); // ----------------------------------------------------------------------------- // --SECTION-- private variables // ----------------------------------------------------------------------------- private: ///////////////////////////////////////////////////////////////////////////// /// @brief name ///////////////////////////////////////////////////////////////////////////// string const _name; ///////////////////////////////////////////////////////////////////////////// /// @brief monopolistic jobs ///////////////////////////////////////////////////////////////////////////// basics::ConditionVariable _accessQueue; ///////////////////////////////////////////////////////////////////////////// /// @brief list of ready jobs ///////////////////////////////////////////////////////////////////////////// list _readyJobs; ///////////////////////////////////////////////////////////////////////////// /// @brief current running job ///////////////////////////////////////////////////////////////////////////// set _runningJobs; ///////////////////////////////////////////////////////////////////////////// /// @brief maximum queue size (number of jobs) ///////////////////////////////////////////////////////////////////////////// size_t _maxSize; ///////////////////////////////////////////////////////////////////////////// /// @brief queue is shutting down ///////////////////////////////////////////////////////////////////////////// volatile sig_atomic_t _stopping; ///////////////////////////////////////////////////////////////////////////// /// @brief monopolistic job ///////////////////////////////////////////////////////////////////////////// DispatcherThread * _monopolizer; ///////////////////////////////////////////////////////////////////////////// /// @brief list of started threads ///////////////////////////////////////////////////////////////////////////// set _startedThreads; ///////////////////////////////////////////////////////////////////////////// /// @brief list of stopped threads ///////////////////////////////////////////////////////////////////////////// list _stoppedThreads; ///////////////////////////////////////////////////////////////////////////// /// @brief number of started jobs ///////////////////////////////////////////////////////////////////////////// size_t _nrStarted; ///////////////////////////////////////////////////////////////////////////// /// @brief number of threads that are up ///////////////////////////////////////////////////////////////////////////// size_t _nrUp; ///////////////////////////////////////////////////////////////////////////// /// @brief number of running jobs ///////////////////////////////////////////////////////////////////////////// size_t _nrRunning; ///////////////////////////////////////////////////////////////////////////// /// @brief number of waiting jobs ///////////////////////////////////////////////////////////////////////////// size_t _nrWaiting; ///////////////////////////////////////////////////////////////////////////// /// @brief number of stopped jobs ///////////////////////////////////////////////////////////////////////////// size_t _nrStopped; ///////////////////////////////////////////////////////////////////////////// /// @brief number of special jobs ///////////////////////////////////////////////////////////////////////////// size_t _nrSpecial; ///////////////////////////////////////////////////////////////////////////// /// @brief total number of threads ///////////////////////////////////////////////////////////////////////////// size_t _nrThreads; ///////////////////////////////////////////////////////////////////////////// /// @brief scheduler ///////////////////////////////////////////////////////////////////////////// Scheduler* _scheduler; ///////////////////////////////////////////////////////////////////////////// /// @brief dispatcher ///////////////////////////////////////////////////////////////////////////// Dispatcher* _dispatcher; ///////////////////////////////////////////////////////////////////////////// /// @brief thread creator function ///////////////////////////////////////////////////////////////////////////// Dispatcher::newDispatcherThread_fptr createDispatcherThread; }; } } #endif // ----------------------------------------------------------------------------- // --SECTION-- END-OF-FILE // ----------------------------------------------------------------------------- // Local Variables: // mode: outline-minor // outline-regexp: "/// @brief\\|/// {@inheritDoc}\\|/// @addtogroup\\|/// @page\\|// --SECTION--\\|/// @\\}" // End: