Subversion Repositories openrisc

//==========================================================================

//

//      sched/bitmap.cxx

//

//      Bitmap scheduler class implementation

//

//==========================================================================

//####ECOSGPLCOPYRIGHTBEGIN####

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

// This file is part of eCos, the Embedded Configurable Operating System.

// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.

//

// eCos 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 or (at your option) any later version.

//

// eCos 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 eCos; if not, write to the Free Software Foundation, Inc.,

// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.

//

// As a special exception, if other files instantiate templates or use macros

// or inline functions from this file, or you compile this file and link it

// with other works to produce a work based on this file, this file does not

// by itself cause the resulting work to be covered by the GNU General Public

// License. However the source code for this file must still be made available

// in accordance with section (3) of the GNU General Public License.

//

// This exception does not invalidate any other reasons why a work based on

// this file might be covered by the GNU General Public License.

//

// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.

// at http://sources.redhat.com/ecos/ecos-license/

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

//####ECOSGPLCOPYRIGHTEND####

//==========================================================================

//#####DESCRIPTIONBEGIN####

//

// Author(s):   nickg

// Contributors:        nickg

// Date:        1997-09-16

// Purpose:     Bitmap scheduler class implementation

// Description: This file contains the implementations of

//              Cyg_Scheduler_Implementation and Cyg_SchedThread_Implementation.

//              

//

//####DESCRIPTIONEND####

//

//==========================================================================

#include <pkgconf/kernel.h>

#include <cyg/kernel/ktypes.h>             // base kernel types

#include <cyg/infra/cyg_trac.h>           // tracing macros

#include <cyg/infra/cyg_ass.h>            // assertion macros

#include <cyg/kernel/sched.hxx>            // our header

#include <cyg/hal/hal_arch.h>           // Architecture specific definitions

#include <cyg/kernel/thread.inl>           // thread inlines

#include <cyg/kernel/sched.inl>            // scheduler inlines

#ifdef CYGSEM_KERNEL_SCHED_BITMAP

//==========================================================================

// Cyg_Scheduler_Implementation class members

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

// Constructor.

Cyg_Scheduler_Implementation::Cyg_Scheduler_Implementation()

{

    CYG_REPORT_FUNCTION();

    // At present we cannot init run_queue here because the absence of

    // ordering of static constructors means that we could do this

    // after the static idle thread has been created. (Guess how I

    // found this out!)    

//    run_queue = 0;

}

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

// Choose the best thread to run next

Cyg_Thread *Cyg_Scheduler_Implementation::schedule()

{

    CYG_REPORT_FUNCTION();

    // The run queue may _never_ be empty, there is always

    // an idle thread at the lowest priority.

    CYG_ASSERT(run_queue != 0, "Run queue empty");

    cyg_uint32 index;

    HAL_LSBIT_INDEX(index, run_queue);

    return thread_table[index];

}

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

void Cyg_Scheduler_Implementation::add_thread(Cyg_Thread *thread)

{

    CYG_REPORT_FUNCTION();

    CYG_ASSERT((CYG_THREAD_MIN_PRIORITY >= thread->priority)

               && (CYG_THREAD_MAX_PRIORITY <= thread->priority),

               "Priority out of range!");

    CYG_ASSERT( thread_table[thread->priority] == NULL ||

                thread_table[thread->priority] == thread,

                "Duplicate thread priorities" );

    CYG_ASSERT( (run_queue & (1<<thread->priority)) == 0,

                "Run queue bit already set" );

    // If the thread is on some other queue, remove it

    // here.

    if( thread->queue != NULL )

    {

        thread->queue->remove(thread);

        thread->queue = NULL;

    }

    run_queue |= 1<<thread->priority;

    // If the new thread is higher priority than the

    // current thread, request a reschedule.

    if( thread->priority < Cyg_Scheduler::get_current_thread()->priority )

        set_need_reschedule();

}

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

void Cyg_Scheduler_Implementation::rem_thread(Cyg_Thread *thread)

{

    CYG_REPORT_FUNCTION();

    CYG_ASSERT( thread_table[thread->priority] == thread,

                "Invalid thread priority" );

    CYG_ASSERT( (run_queue & (1<<thread->priority)) != 0,

                "Run queue bit not set" );

    run_queue &= ~(1<<thread->priority);

    if( thread == Cyg_Scheduler::get_current_thread() )

        set_need_reschedule();

}

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

// Set up initial idle thread

void Cyg_Scheduler_Implementation::set_idle_thread( Cyg_Thread *thread, HAL_SMP_CPU_TYPE cpu )

{

    CYG_REPORT_FUNCTION();

    // Make the thread the current thread for this CPU.

    current_thread[cpu] = thread;

    // This will insert the thread in the run queues and make it

    // available to execute.

    thread->resume();

}

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

// register thread with scheduler

void Cyg_Scheduler_Implementation::register_thread(Cyg_Thread *thread)

{

    CYG_REPORT_FUNCTION();

    thread_table[thread->priority] = thread;

}

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

// deregister thread

void Cyg_Scheduler_Implementation::deregister_thread(Cyg_Thread *thread)

{

    CYG_REPORT_FUNCTION();

    thread_table[thread->priority] = NULL;

}

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

// Test the given priority for uniqueness

cyg_bool Cyg_Scheduler_Implementation::unique( cyg_priority priority)

{

    CYG_REPORT_FUNCTION();

    return thread_table[priority] == NULL;

}

//==========================================================================

// Cyg_Cyg_SchedThread_Implementation class members

Cyg_SchedThread_Implementation::Cyg_SchedThread_Implementation

(

    CYG_ADDRWORD sched_info

)

{

    CYG_REPORT_FUNCTION();

#if 1

    // Assign this thread's priority to the supplied sched_info

    // or the next highest priority available.

    priority = cyg_priority(sched_info);

    while( !Cyg_Scheduler::scheduler.unique(priority) )

        priority++;

#else    

    // Assign initial priorities to threads in descending order of

    // creation.

    static cyg_priority init_priority = 0;

    priority = init_priority++;

#endif

}

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

void Cyg_SchedThread_Implementation::yield()

{

    CYG_REPORT_FUNCTION();

    // We cannot yield in this scheduler

}

//==========================================================================

// Cyg_ThreadQueue_Implementation class members

Cyg_ThreadQueue_Implementation::Cyg_ThreadQueue_Implementation()

{

    CYG_REPORT_FUNCTION();

    wait_queue = 0;                       // empty queue

    CYG_REPORT_RETURN();

}

void Cyg_ThreadQueue_Implementation::enqueue(Cyg_Thread *thread)

{

    CYG_REPORT_FUNCTION();

    wait_queue |= 1<<thread->priority;

    thread->queue = CYG_CLASSFROMBASE(Cyg_ThreadQueue,

                                      Cyg_ThreadQueue_Implementation,

                                      this);

}

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

Cyg_Thread *Cyg_ThreadQueue_Implementation::dequeue()

{

    CYG_REPORT_FUNCTION();

    // Isolate ls bit in run_queue.

    cyg_sched_bitmap next_thread = wait_queue & -wait_queue;

    if( next_thread == 0 ) return NULL;

    wait_queue &= ~next_thread;

    cyg_uint32 index;

    HAL_LSBIT_INDEX(index, next_thread);

    Cyg_Thread *thread = Cyg_Scheduler::scheduler.thread_table[index];

    thread->queue = NULL;

    return thread;

}

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

Cyg_Thread *Cyg_ThreadQueue_Implementation::highpri()

{

    CYG_REPORT_FUNCTION();

    // Isolate ls bit in run_queue.

    cyg_sched_bitmap next_thread = wait_queue & -wait_queue;

    if( next_thread == 0 ) return NULL;

    cyg_uint32 index;

    HAL_LSBIT_INDEX(index, next_thread);

    return Cyg_Scheduler::scheduler.thread_table[index];

}

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

void Cyg_ThreadQueue_Implementation::remove(Cyg_Thread *thread)

{

    CYG_REPORT_FUNCTION();

    wait_queue &= ~(1<<thread->priority);

    thread->queue = NULL;

}

#endif

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

// EOF sched/bitmap.cxx