VRS - The Virtual Rendering System

version 3.3

taskmanager.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2008 Computer Graphics Systems Group at the 
 * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
 *
 * This  library  is  free  software; you can redistribute it and/or  modify it
 * under the terms of the GNU Lesser General Public  License  as  published  by
 * the  Free  Software  Foundation;  either  version 2.1 of the License, or (at
 * your option) any later version. This library  is  distributed  in  the  hope
 * that  it will be useful, but  WITHOUT ANY WARRANTY; without even the implied
 * warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE.  See  the
 * GNU Lesser General Public License for more details. You should have received
 * a copy of the GNU Lesser+ General Public License along with this library; if
 * not, write to the FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA, 02111-1307, USA.
 ******************************************************************************/

#ifndef VRS_MT_TASKMANAGER_H
#define VRS_MT_TASKMANAGER_H

#include <vrs/callback.h>

#include <stdexcept>

namespace VRS {
    namespace MT {

        class TaskManager;

        class VRS_CORE_API TaskBase :
            public VRS::SharedObj
        {
        public:
            VRS_TYPEINFO(TaskBase, VRS::SharedObj);

            enum State {
                State_Queued, 
                State_Running, 
                State_Canceling, 
                State_Finished, 
                State_Canceled, 
                State_Exception 
            }; // enum State

            virtual State state() const;

            virtual bool ended() const;

            virtual double priority() const;

            virtual void changePriority(double newPriority);

            virtual void wait() const;

            virtual bool wait(double seconds) const;

            virtual void cancel();

        public:
            static void Sleep(double seconds);

            static void Yield();

            static bool ShouldBeCanceled();

            static void DoCancelation();

        protected:
            TaskBase(
                double priority,
                double cancelIfNotStartedWithinSecond,
                bool finished
            );

        public:
            virtual ~TaskBase();

        protected:
            virtual void work() = 0;

            void workImpl();

        protected:
            friend class TaskManager;

        public:
            struct Impl;
            Impl* const m_impl;
        }; // class TaskBase

        template<class RESULT_TYPE>
        class Task :
            public TaskBase
        {
        public:
            const RESULT_TYPE& result() const {
                wait();
                switch(state()) {
                    case State_Finished:    return m_result;
                    case State_Canceled:    throw std::exception("task has been canceled");
                    case State_Exception:   throw std::exception("exception during task execution");
                    case State_Queued:
                    case State_Running:
                    case State_Canceling:
                    default:                throw std::exception("unreachable code reached");
                }
                return m_result; // to make the compiler happy
            }

        protected:
            friend class TaskManager;

            Task(
                SO<CallbackR<RESULT_TYPE> > taskCallback,
                double priority,
                double cancelIfNotStartedWithinSeconds
            ) :
                TaskBase(priority, cancelIfNotStartedWithinSeconds, false),
                m_taskCallback(taskCallback),
                m_result()
            {
                VRS_CheckArg(taskCallback, "no task callback");
            }

            Task(
                const RESULT_TYPE& result
            ) :
                TaskBase(0.0, 0.0, true),
                m_taskCallback(NULL),
                m_result(result)
            { }

            virtual void work() {
                if(!m_taskCallback) { return; }
                m_result = m_taskCallback->callback();
                m_taskCallback = NULL; // to free some resources
            }

        private:
            SO<CallbackR<RESULT_TYPE> > m_taskCallback;
            RESULT_TYPE m_result;
        }; // class Task<RESULT_TYPE>

        class VRS_CORE_API TaskManager {
        public:
            template<class RESULT_TYPE>
            static SO<Task<RESULT_TYPE> > AddTask(
                SO<CallbackR<RESULT_TYPE> > taskCallback,
                double priority = 0.5,
                double cancelIfNotStartedWithinSeconds = 0.0
            ) {
                SO<Task<RESULT_TYPE> > task = new Task<RESULT_TYPE>(taskCallback, priority, cancelIfNotStartedWithinSeconds);
                ScheduleTask(task);
                return task;
            }

            template<class RESULT_TYPE>
            static SO<Task<RESULT_TYPE> > AddResult(
                const RESULT_TYPE& result
            ) {
                SO<Task<RESULT_TYPE> > task = new Task<RESULT_TYPE>(result);
                return task;
            }

            static size_t QueuedTasks();

            static void CancelAllTasks();

        protected:
            static void ScheduleTask(
                SO<TaskBase> task
            );

            static void DispatchTasks();

            static void Initialize();
        }; // class TaskManager

    } // namespace MT
} // namespace VRS

#endif // VRS_MT_TASKMANAGER_H

---

Generated on Thu May 24 06:00:16 2012 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact