scheduler.h

Linux下比较早的基于命令行的DVD播放器

//
// Copyright (c) 2003 by Istv醤 V醨adi
//
// This file is part of dxr3Player, a DVD player written specifically 
// for the DXR3 (aka Hollywood+) decoder card.

// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#ifndef DXR3PLAYER_SCHED_SCHEDULER_H
#define DXR3PLAYER_SCHED_SCHEDULER_H
//------------------------------------------------------------------------------

#include "Schedulable.h"

#include "util/DefaultAllocator.h"
#include "util/FileDescriptor.h"

#include "types.h"

#include <vector>
#include <set>

#include <cassert>

//------------------------------------------------------------------------------

namespace sched {

//------------------------------------------------------------------------------

class Schedulable;
class FDWaitCondition;

//------------------------------------------------------------------------------

/**
 * The scheduler. It is a singleton. Get the instance using Scheduler::get().
 */
class Scheduler
{
private:
    /**
     * The type for file descriptor-based wait conditions
     */
    typedef std::set<FDWaitCondition*, std::less<FDWaitCondition*>, DefaultAllocator> fdWaitConditions_t;

    /**
     * The pair to store schedulables in.
     */
    typedef std::pair<Schedulable*, bool> schedulableInfo_t;

    /**
     * Allocator for schedulables.
     */
    typedef DefaultAllocatorTemplate<schedulableInfo_t> SchedulableAllocator;

    /**
     * The type for schedulables.
     */
    typedef std::vector<schedulableInfo_t, SchedulableAllocator> schedulables_t;

public:
    /**
     * Initialize the instance.
     */
    static void initialize(size_t stackSize = 128 * 1024);

    /**
     * Get the instance. Can be called only after an initialize().
     */
    static Scheduler& get();

    /**
     * Determine if the current thread is interrupted or not.
     */
    static bool isInterrupted();

    /**
     * Call continueBurst() on the current Schedulable
     *
     * @see Schedulable::continueBurst
     */
    static void continueBurst(const char* ownerName);

    /**
     * Call yield() on the current Schedulable
     *
     * @see Schedulable::yield
     */
    static void yield(const char* ownerName);
    
    /**
     * Call sleep() on the current Schedulable
     *
     * @see Schedulable::yield
     */
    static void sleep(const char* ownerName,
                      millis_t timeout = INVALID_MILLIS);
    
    /**
     * Call sleepInterruptible() on the current Schedulable
     *
     * @see Schedulable::yield
     */
    static void sleepInterruptible(const char* ownerName,
                                   millis_t timeout = INVALID_MILLIS);
    
    /**
     * Call wait() on the current Schedulable
     *
     * @see Schedulable::wait
     */
    static bool wait(WaitCondition& cond, millis_t timeout = INVALID_MILLIS);
    
    /**
     * Call waitInterruptible() on the current Schedulable
     *
     * @see Schedulable::wait
     */
    static bool waitInterruptible(WaitCondition& cond, millis_t timeout = INVALID_MILLIS);
    
private:
    /**
     * The only instance.
     */
    static Scheduler* instance;
    
    /**
     * The Schedulable running currently.
     */
    static Schedulable* currentSchedulable;

    /**
     * The top of the stack of the next Schedulable.
     */
    char* nextStackTop;

    /**
     * The stack state of the scheduler.
     */
    jmp_buf state;

    /**
     * The schedulables.
     */
    schedulables_t schedulables;

    /**
     * The file descriptor-based wait conditions
     */
    fdWaitConditions_t fdWaitConditions;

    /**
     * The start clock.
     */
    long startClock;

    /**
     * Construct the scheduler.
     */
    Scheduler(size_t stackSize);

public:
    /**
     * Run the scheduler.
     */
    void run();

    /**
     * Print the status of the scheduler and the schedulables.
     */
    void printStatus();

    /**
     * Signal all schedulables to quit.
     */
    void quit() const;

private:
    /**
     * Add the given schedulable.
     *
     * @return the bottom of the next stack
     */
    char* addSchedulable(Schedulable* schedulable, size_t stackSize);

    /**
     * Add the given file descriptor-based wait condition.
     */
    void addFDWaitCondition(FDWaitCondition* cond);

    /**
     * Remove the given file descriptor-based wait condition.
     */
    void removeFDWaitCondition(FDWaitCondition* cond);

    /**
     * Get the earliest time a schedulabe times out. 
     *
     * @return the earliest time, or 0 if there is at least one
     * schedulable, that is runnable at once.
     */
    millis_t getEarliestTime() const;
    
    /**
     * Get the file descriptors to watch.
     *
     * @return the largest file descriptor, or -1 if no file
     * descriptor should be watched.
     */
    int getFileDescriptors(fd_set& readFDs, fd_set& writeFDs) const;

    /**
     * Set the file descriptor-based wait conditions for the file
     * descriptors that are available.
     */
    void setFileDescriptors(const fd_set& readFDs,
                            const fd_set& writeFDs) const;

    /**
     * Set the runnability of the schedulables.
     */
    void setRunnability();

    /**
     * Run the runnable schedulables.
     */
    void runRunnables();

    /**
     * Resume the scheduler.
     */
    void resume();

    /**
     * Run the schedulable.
     */
    void runSchedulable(Schedulable* schedulable);

    friend class Schedulable;
    friend class FDWaitCondition;
};

//------------------------------------------------------------------------------
// Inline definitions
//------------------------------------------------------------------------------

inline Scheduler& Scheduler::get()
{
    assert(instance!=0);
    return *instance;
}

//------------------------------------------------------------------------------

inline bool Scheduler::isInterrupted()
{
    assert(currentSchedulable!=0);
    return currentSchedulable->isInterrupted();
}
    
//------------------------------------------------------------------------------

inline void Scheduler::continueBurst(const char* ownerName)
{
    assert(currentSchedulable!=0);
    currentSchedulable->continueBurst(ownerName);
}

//------------------------------------------------------------------------------

inline void Scheduler::yield(const char* ownerName)
{
    assert(currentSchedulable!=0);
    currentSchedulable->yield(ownerName);
}
    
//------------------------------------------------------------------------------

inline void Scheduler::sleep(const char* ownerName, millis_t timeout)
{
    assert(currentSchedulable!=0);
    currentSchedulable->sleep(ownerName, timeout);
}
    
//------------------------------------------------------------------------------

inline void Scheduler::sleepInterruptible(const char* ownerName, millis_t timeout)
{
    assert(currentSchedulable!=0);
    currentSchedulable->sleepInterruptible(ownerName, timeout);
}
    
//------------------------------------------------------------------------------

inline bool Scheduler::wait(WaitCondition& cond, millis_t timeout)
{
    assert(currentSchedulable!=0);
    return currentSchedulable->wait(cond, timeout);
}

//------------------------------------------------------------------------------

inline bool Scheduler::waitInterruptible(WaitCondition& cond, millis_t timeout)
{
    assert(currentSchedulable!=0);
    return currentSchedulable->waitInterruptible(cond, timeout);
}

//------------------------------------------------------------------------------

inline void Scheduler::resume()
{
    longjmp(state, 0);
}

//------------------------------------------------------------------------------

} /* namespace sched */

//------------------------------------------------------------------------------
#endif // DXR3PLAYER_SCHED_SCHEDULER_H

// Local variables:
// mode: c++
// End: