scheduler.cc

Go to the documentation of this file.

// scheduler.cc
//      Routines to choose the next thread to run, and to dispatch to
//      that thread.
//
//      These routines assume that interrupts are already disabled.
//      If interrupts are disabled, we can assume mutual exclusion
//      (since we are on a uniprocessor).
//
//      NOTE: We can't use Locks to provide mutual exclusion here, since
//      if we needed to wait for a lock, and the lock was busy, we would 
//      end up calling FindNextToRun(), and that would put us in an 
//      infinite loop.
//
//      Very simple implementation -- no priorities, straight FIFO.
//      Might need to be improved in later assignments.
//
// Copyright (c) 1992-1993 The Regents of the University of California.
// All rights reserved.  See copyright.h for copyright notice and limitation 
// of liability and disclaimer of warranty provisions.

#include "copyright.h"
#include "scheduler.h"
#include "system.h"
#include "thread.h"
#include <signal.h>
#include <time.h>
#include <unistd.h>
#include <setjmp.h>


sigjmp_buf schd_jmp;
Thread     bogus_th("starter");
sigset_t   timer_mask;
timer_t    timer_id;
itimerspec timer_value;
itimerspec timer_empty;

bool       preempt = false;

//----------------------------------------------------------------------
// SetPreemption
// Global Function to turn on Preemption int the code.
//----------------------------------------------------------------------

void SetPreemption()
{
  preempt = true;
}

//----------------------------------------------------------------------
// Scheduler::Scheduler
//      Initialize the list of ready but not running threads to empty.
//----------------------------------------------------------------------

Scheduler::Scheduler()
{ 
    readyList = new List;
}

//----------------------------------------------------------------------
// Scheduler::~Scheduler
//      De-allocate the list of ready threads.
//----------------------------------------------------------------------

Scheduler::~Scheduler()
{
    delete readyList;
}

int Scheduler::IsEmpty()
{
    return readyList->IsEmpty(); // default*/
}

//----------------------------------------------------------------------
// Scheduler::ReadyToRun
//      Mark a thread as ready, but not running.
//      Put it on the ready list, for later scheduling onto the CPU.
//
//      "thread" is the thread to be put on the ready list.
//----------------------------------------------------------------------

void Scheduler::ReadyToRun (Thread *thread)
{
    thread->setStatus(READY);
    readyList->Append((void *)thread);
}

//----------------------------------------------------------------------
// Scheduler::FindNextToRun
//      Return the next thread to be scheduled onto the CPU.
//      If there are no ready threads, return NULL.
// Side effect:
//      Thread is removed from the ready list.
//----------------------------------------------------------------------
Thread* Scheduler::FindNextToRun ()
{
    return (Thread *)readyList->Remove();
}



//----------------------------------------------------------------------
// Scheduler::Print
//      Print the scheduler state -- in other words, the contents of
//      the ready list.  For debugging.
//----------------------------------------------------------------------
void Scheduler::Print()
{
    printf("Ready list contents:\n");
    readyList->Mapcar((VoidFunctionPtr) ThreadPrint);
}



//----------------------------------------------------------------------
// timer interrupt handler that is called when SIGALRM is generated
//----------------------------------------------------------------------

void Scheduler::timerIntH(int sig)
{
    static int counter = 0;

    if (!PREEMPTION && !preempt)
        return;

    timerCount++;
    counter++;
    if (counter == TICKS_PER_SEC) // the timer should be called about 15 times per second
    {
        counter = 0;
        secCount++; // increment the elapsed seconds
    }
    // arm the timer again
    timer_settime(timer_id, 0, &timer_value, 0);


    if (interrupt->level == IntOff || scheduler->IsEmpty())
    {
        if (interrupt->level == IntOff) // preempt this thread after the sys call is done
        {
            interrupt->YieldOnReturn();
        }
        return;
    }

    if (currentThread)
    {
        if (sigsetjmp(currentThread->cbuff, 1) == 0)
            schedule();
    }
    else // just call schedule as nothing is running at the moment besides the main proc
        schedule();

    return;
}

//----------------------------------------------------------------------
// Inializes the timer handler and the signal mask.  then sets off the
// timer.
//----------------------------------------------------------------------
void timerInit()
{
    struct sigaction tact;

    //setup the timer handler and tell it to use an alternative signal stack
    memset(&tact, 0, sizeof(struct sigaction));
    tact.sa_handler = Scheduler::timerIntH;
    tact.sa_flags = 0;
    sigemptyset(&tact.sa_mask);

    sigemptyset(&timer_mask);
    sigaddset(&timer_mask, SIGALRM);

    if (sigaction(SIGALRM, &tact, NULL) != 0)
        printf("Failed to set the alarm handler\n");

    timer_create(CLOCK_REALTIME, 0, &timer_id);
    memset(&timer_value, 0, sizeof(struct itimerspec));
    memset(&timer_empty, 0, sizeof(struct itimerspec));
    timer_value.it_value.tv_sec = 0;
    timer_value.it_value.tv_nsec = NSECS_PER_SEC / 15;  // 0.0666 sec
    timer_settime(timer_id, 0, &timer_value, 0);
}

// ---------------------------------------------------------------
// IMPORTANT!!!!!!!!!!!!!!!!!!!
// The function assumes that the current thread's context has
// been ALREADY saved!  (since schedule happens in the context
// of the main thread). It just puts the current thread on the
// ready list and selects the next one for execution and then does
// a siglongjmp
//
// DO NOT TOUCH THIS FUNCTION:
// the scheduling policy can be done by changing the FindNextToRun
// function.
// ---------------------------------------------------------------
void schedule()
{
    Thread *nextThread = 0;

    // disarm the alarm
    timer_settime(timer_id, 0, &timer_empty, 0);

    nextThread = scheduler->FindNextToRun();

    if (threadToBeDestroyed != NULL)
    {
        currentThread = 0;
        DEBUG('t', "Purge Thread \"%s\"\n", threadToBeDestroyed->getName());
        delete threadToBeDestroyed;
        threadToBeDestroyed = NULL;
    }

    if (nextThread != NULL)
    {
        if (currentThread)
            scheduler->ReadyToRun(currentThread); // set to READY

        currentThread = nextThread;    // switch to the next thread
        //swap over here
        if (!currentThread->started)
        {
            currentThread->started = 1;
            currentThread->setStatus(RUNNING);    // set to RUNNING
            DEBUG('t', "^Create^ \"%s\"\n", currentThread->getName());
            interrupt->Enable();
            timer_settime(timer_id, 0, &timer_value, 0);
            // use the NachOS switch to get the thread going for the
            // time and then begin to use the siglongjmp way
            SWITCH(&bogus_th, currentThread);
        }
        else
        {
            DEBUG('t', "Sched \"%s\"\n", currentThread->getName());
            currentThread->setStatus(RUNNING);    // set to RUNNING
            interrupt->Enable();
            timer_settime(timer_id, 0, &timer_value, 0);
            siglongjmp(currentThread->cbuff, 1);
        }
    }
    else if (currentThread)// only a single thread is left
    {
            DEBUG('t', "Only Thread \"%s\"\n", currentThread->getName());
            currentThread->setStatus(RUNNING);    // set to RUNNING
            interrupt->Enable();
            timer_settime(timer_id, 0, &timer_value, 0);
            sigprocmask(SIG_UNBLOCK, &timer_mask, 0);
            siglongjmp(currentThread->cbuff, 1);
    }
    else
    {
        // we are spinning while something is sleeping
        interrupt->Enable();
        timer_settime(timer_id, 0, &timer_value, 0);
    }
}

---