scheduler.cc

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

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

#include "Scheduler.h"

#include "FDWaitCondition.h"

#include "util/Util.h"
#include "util/Log.h"
#include "util/POSIX.h"

#include <sys/time.h>
#include <sys/times.h>

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

using sched::Scheduler;
using sched::Schedulable;

using std::make_pair;

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

Scheduler* Scheduler::instance = 0;

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

Schedulable* Scheduler::currentSchedulable = 0;

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

void Scheduler::initialize(size_t stackSize)
{
    static Scheduler scheduler(stackSize);

    instance = &scheduler;
}

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

Scheduler::Scheduler(size_t stackSize) 
{
    char x;
    
    size_t stackTop = reinterpret_cast<size_t>(&x);

    stackTop -= stackSize;
    stackTop /= 4096;
    stackTop *= 4096;

    nextStackTop = reinterpret_cast<char*>(stackTop);

    struct tms tms;
    startClock = times(&tms);
}

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

void Scheduler::run()
{
    Log::debug("sched::Scheduler::run: %u schedulables\n", schedulables.size());

    while(true) {
        runRunnables();

        fd_set readFDs; FD_ZERO(&readFDs);
        fd_set writeFDs; FD_ZERO(&writeFDs);
        int maxFD = getFileDescriptors(readFDs, writeFDs);

        millis_t earliestTime = getEarliestTime();

        struct timeval zero_tv = { tv_sec: 0, tv_usec: 0 };
        struct timeval tv;
        
        struct timeval* tvPtr = 0;
        
        if (earliestTime==0) {
            tvPtr = &zero_tv;
        } else if (earliestTime!=INVALID_MILLIS) {
            millis_t currentTime = Util::currentTimeMillis();
            
            millis_t diffTime = 0;
            if (earliestTime > (currentTime + 3) ) {
                diffTime = earliestTime - currentTime;
            }
            
            tv.tv_sec  = diffTime / 1000;
            tv.tv_usec = (diffTime % 1000) * 1000;
            tvPtr = &tv;
        }
        
        int numDescriptors = 0;
        if (maxFD<0) {
            if (tvPtr==0) {
                break;
            } else if (tvPtr!=&zero_tv) {
                numDescriptors = POSIX::select(0, 0, 0, 0, tvPtr);
            }
        } else {
            numDescriptors = POSIX::select(maxFD+1, &readFDs, &writeFDs, 0, tvPtr);
        }
        
        setFileDescriptors(readFDs, writeFDs);
        
        setRunnability();
    }
}

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

void Scheduler::printStatus()
{
    millis_t currentTime = Util::currentTimeMillis();

    Log::debug("Scheduler with %u schedulables at %llu\n",
               schedulables.size(), currentTime);

    struct tms tms;
    long currentClock = times(&tms);
    
    long elapsedClock = currentClock - startClock;

    long  userClock = tms.tms_utime;

    long sysClock = tms.tms_stime;

    Log::debug("  time elapsed (ticks): %ld, user: %ld (%5.2f %%), sys: %ld (%5.2f %%), total: %ld (%5.2f %%)\n",
               elapsedClock, 
               userClock, double(userClock)*100.0/double(elapsedClock),
               sysClock, double(sysClock)*100.0/double(elapsedClock),
               userClock+sysClock, double(userClock + sysClock)*100.0/double(elapsedClock));
    
    for(schedulables_t::const_iterator i = schedulables.begin();
        i!=schedulables.end(); ++i)
    {
        const Schedulable* schedulable = (*i).first;

        Log::debug("Schedulable %s:\n", schedulable->name);

        const WaitCondition* cond = schedulable->waitCondition;
        if (cond!=0) {

            const char* interruptableClause = "";
            if (schedulable->waitIsInterruptible) {
                interruptableClause = "interruptably ";
            }

            char timeoutClause[64] = { 0 };
            millis_t timeout = schedulable->waitTimeout;
            if (timeout!=INVALID_MILLIS) {
                snprintf(timeoutClause, sizeof(timeoutClause),
                         " with timeout %llu (%lld)", timeout, timeout - currentTime);
            }

            const char* interruptedClause = "";
            if (schedulable->interruptPending) {
                interruptableClause = " An interrupt is pending.";
            }

            Log::debug("  is %swaiting on %s/%s (%sfulfilled)%s.%s\n", 
                       interruptableClause,
                       cond->getOwnerName(),
                       cond->getName(),
                       cond->check() ? "" : "not ",
                       timeoutClause,
                       interruptedClause);
        } else {
            Log::debug("  is running\n");
        }
        if ( (*i).second ) {
            Log::debug("  is runnable\n");
        }
        schedulable->printStatus();
    }

}

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

void Scheduler::quit() const
{
    for(schedulables_t::const_iterator i = schedulables.begin();
        i!=schedulables.end(); ++i)
    {
        Schedulable* schedulable = (*i).first;
     
        schedulable->quit();
    }
}

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

char* Scheduler::addSchedulable(Schedulable* schedulable, size_t stackSize)
{
    schedulables.push_back(schedulableInfo_t(schedulable, true));

    nextStackTop -= stackSize;
    return nextStackTop;
}

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

void Scheduler::addFDWaitCondition(FDWaitCondition* cond)
{
    fdWaitConditions.insert(cond);
}

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

void Scheduler::removeFDWaitCondition(FDWaitCondition* cond)
{
    fdWaitConditions.erase(cond);
}

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

millis_t Scheduler::getEarliestTime() const
{
    millis_t earliestTime = INVALID_MILLIS;

    for(schedulables_t::const_iterator i = schedulables.begin();
        i!=schedulables.end() && earliestTime>0; ++i)
    {
        Schedulable* schedulable = (*i).first;
        
        if (schedulable->isRunnable()) {
            earliestTime = 0;
        } else {
            millis_t time = schedulable->waitTimeout;
            if (time<earliestTime) {
                earliestTime = time;
            }
        }
    }

    return earliestTime;
}

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

int Scheduler::getFileDescriptors(fd_set& readFDs, fd_set& writeFDs) const
{
    int maxFD = -1;

    for(fdWaitConditions_t::const_iterator i = fdWaitConditions.begin();
        i!=fdWaitConditions.end(); ++i)
    {
        FDWaitCondition* cond = *i;
        if (!cond->hasWaiter()) continue;

        int fd = cond->getFileDescriptor();
        if (fd<0) continue;
        
        fd_set& fdset = (cond->isReadable()) ? readFDs : writeFDs;

        FD_SET(fd, &fdset);
        if (fd>maxFD) maxFD = fd;
    }

    return maxFD;
}

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

void Scheduler::setFileDescriptors(const fd_set& readFDs,
                                   const fd_set& writeFDs) const
{
    for(fdWaitConditions_t::const_iterator i = fdWaitConditions.begin();
        i!=fdWaitConditions.end(); ++i)
    {
        FDWaitCondition* cond = *i;
        if (!cond->hasWaiter()) continue;

        int fd = cond->getFileDescriptor();
        if (fd<0) continue;
        
        const fd_set& fdset = (cond->isReadable()) ? readFDs : writeFDs;

        if (FD_ISSET(fd, &fdset)) {
            cond->set();
        }
    }
}

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

void Scheduler::setRunnability()
{
    millis_t currentTime = Util::currentTimeMillis();

    for(schedulables_t::iterator i = schedulables.begin();
        i!=schedulables.end(); ++i)
    {
        schedulableInfo_t& schedulableInfo = *i;

        schedulableInfo.second = 
            schedulableInfo.first->isRunnable(currentTime);
    }
}

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

void Scheduler::runRunnables()
{
    for(schedulables_t::const_iterator i = schedulables.begin();
        i!=schedulables.end(); ++i)
    {
        const schedulableInfo_t& schedulableInfo = *i;
        
        if (schedulableInfo.second) {
            runSchedulable(schedulableInfo.first);
        }
    }
}

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

void Scheduler::runSchedulable(Schedulable* schedulable)
{
    if (setjmp(state)==0) {
        currentSchedulable = schedulable;
        schedulable->resume();
    } else {
        currentSchedulable = 0;
    }
}

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