jobqueue.h

/*
 * Orca-Robotics Project: Components for robotics
 *               http://!orca-robotics.sf.net/
 * Copyright (c) 2004-2009 Alex Brooks, Alexei Makarenko, Tobias Kaupp
 *
 * This distribution is licensed to you under the terms described in
 * the LICENSE file included in this distribution.
 *
 */

#ifndef HYDROICEUTIL_JOB_QUEUE_H
#define HYDROICEUTIL_JOB_QUEUE_H

#include <IceUtil/Handle.h>
#include <IceUtil/Shared.h>
#include <IceUtil/Monitor.h>
#include <IceUtil/Mutex.h>
#include <gbxutilacfr/stoppable.h>
#include <gbxsickacfr/gbxiceutilacfr/thread.h>
#include <hydroutil/uncopyable.h>
#include <gbxutilacfr/tracer.h>
#include <vector>
#include <list>

namespace hydroiceutil {


class Job : public gbxutilacfr::Stoppable, public IceUtil::Shared
{
public:
    Job();
    virtual ~Job() {}

    virtual void execute()=0;

    virtual std::string toString() const=0;

    virtual int expectedDuration() const { return -1; };

    void cancel();

    bool isCancelled();

    // from gbxutilacfr::Stoppable
    virtual bool isStopping() { return isCancelled(); };

    bool isTracable_;

private:

    bool isCancelled_;
    IceUtil::Mutex isCancelledMutex_;

};
typedef IceUtil::Handle<Job> JobPtr;

struct JobQueueStatus
{
    int activeJobCount;
    int queuedJobCount;
};

class JobQueue :  public IceUtil::Shared,
                  public IceUtil::Monitor<IceUtil::Mutex>,
                  private hydroutil::Uncopyable
{
public:
    struct Config
    {
        Config() :
            threadPoolSize(1),
            queueSizeWarn(0),
            traceAddEvents(false),
            traceStartEvents(false),
            traceDoneEvents(false),
            traceStalledJobs(false) {};

        void validate( gbxutilacfr::Tracer& tracer );

        int threadPoolSize;
        int queueSizeWarn;
        bool traceAddEvents;
        bool traceStartEvents;
        bool traceDoneEvents;
        bool traceStalledJobs;
//         bool cancelStalledJobs;
    };

    JobQueue( gbxutilacfr::Tracer& tracer, const Config& config=Config() );

    ~JobQueue();

    void stop();

    void add( const JobPtr& job );

    JobQueueStatus status();

    std::string toString();

    //
    // No doxy-tags because these are only used by workers.
    //

    // The worker asks for a job to work on.
    // Blocks until a job arrives
    JobPtr get( gbxiceutilacfr::Thread* thread );

private:
    // incoming job requests
    std::list<JobPtr>               pendingJobs_;

    // worker pool
    std::vector<gbxiceutilacfr::ThreadPtr> workerPool_;
    int activeJobCount_;

    bool isQueueStopping_;

    gbxutilacfr::Tracer& tracer_;
    Config config_;
};
typedef IceUtil::Handle<JobQueue> JobQueuePtr;

} // namespace

#endif