schedulable.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 "Schedulable.h"

#include "WaitCondition.h"
#include "Scheduler.h"

#include "util/Log.h"

#include <cstring>

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

using sched::Schedulable;

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

Schedulable::Schedulable(const char* name, 
                         size_t stackSize,
                         size_t maxBurstSize) :
    name(name),
    waitCondition(0),
    waitTimeout(INVALID_MILLIS),
    waitIsInterruptible(false),
    interruptPending(false),
    toQuit(false),
    maxBurstSize(maxBurstSize),
    burstSize(0)
{
    char* stack = Scheduler::get().addSchedulable(this, stackSize);
    
    Log::debug("sched::Schedulable::Schedulable: new stack frame @%p of size %u\n", stack, stackSize);

    // FIXME: this is Linux/i386 specific
    char x;
    size_t toSkip = (&x) - (stack + stackSize);

    alloca(toSkip);

    initState();
}

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

void Schedulable::printStatus() const
{
}

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

void Schedulable::yield(const char* ownerName)
{
    WaitCondition cond(ownerName, "Schedulable::yield");
    wait(cond, INVALID_MILLIS, false, true);
}

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

void Schedulable::sleep(const char* ownerName, millis_t timeout)
{
    WaitCondition cond(ownerName, "Schedulable::sleep");
    wait(cond, timeout);
}

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

void Schedulable::sleepInterruptible(const char* ownerName,
                                     millis_t timeout)
{
    WaitCondition cond(ownerName, "Schedulable::sleep");
    waitInterruptible(cond, timeout);
}

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

void Schedulable::initState()
{
    if (setjmp(state)!=0) {
        doRun();
    }
}

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

bool Schedulable::isRunnable() const
{
    return 
        (waitCondition!=0) &&
        (waitCondition->check() || 
         (waitIsInterruptible && interruptPending));
}
   
//------------------------------------------------------------------------------

bool Schedulable::isRunnable(millis_t t) const
{
    return 
        (waitCondition!=0) &&
        (waitCondition->check() || 
         (t+20) >= waitTimeout ||
         (waitIsInterruptible && interruptPending));
}

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

void Schedulable::doRun()
{
    run();

    waitCondition = 0;
    waitTimeout = INVALID_MILLIS;

    setjmp(state);
    Scheduler::get().resume();
}

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

void Schedulable::suspend()
{
    if (setjmp(state)==0) {
        burstSize = 0;
        Scheduler::get().resume();
    }
}

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

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

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

bool Schedulable::wait(WaitCondition& cond, 
                       millis_t timeout, bool interruptible, bool fulfilled)
{
//      Log::debug("sched::Schedulable::wait: timeout=%llu, interruptible=%d, fulfilled=%u by %p\n",
//                 timeout, interruptible, fulfilled, this);

    assert(waitCondition==0);

    cond.init(this, fulfilled);

    waitCondition = &cond;
    waitTimeout = timeout;
    waitIsInterruptible = interruptible;

    suspend();

    bool conditionFulfilled = waitCondition->clear();
    
    waitCondition = 0;
    waitTimeout = INVALID_MILLIS;
    waitIsInterruptible = false;

    return conditionFulfilled;
}

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