#ifndef CYGONCE_KERNEL_SCHED_HXX #define CYGONCE_KERNEL_SCHED_HXX //========================================================================== // // sched.hxx // // Scheduler class declaration(s) // //========================================================================== // ####ECOSGPLCOPYRIGHTBEGIN#### // ------------------------------------------- // This file is part of eCos, the Embedded Configurable Operating System. // Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, 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., // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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 v2. // // This exception does not invalidate any other reasons why a work based // on this file might be covered by the GNU General Public License. // ------------------------------------------- // ####ECOSGPLCOPYRIGHTEND#### //========================================================================== //#####DESCRIPTIONBEGIN#### // // Author(s): nickg // Contributors: nickg // Date: 1997-09-09 // Purpose: Define Scheduler class interfaces // Description: These class definitions supply the internal API // used to scheduler threads. // Usage: #include // //####DESCRIPTIONEND#### // //========================================================================== #include #include // assertion macros #include // SMP support // ------------------------------------------------------------------------- // Miscellaneous types #ifdef CYGSEM_KERNEL_SCHED_ASR_SUPPORT typedef void Cyg_ASR( CYG_ADDRWORD data ); // ASR type signature #endif __externC void cyg_scheduler_set_need_reschedule(); // ------------------------------------------------------------------------- // Scheduler base class. This defines stuff that is needed by the // specific scheduler implementation. Each scheduler comprises three // classes: Cyg_Scheduler_Base, Cyg_Scheduler_Implementation which // inherits from it and Cyg_Scheduler which inherits from _it_ in turn. class Cyg_Scheduler_Base : public Cyg_Scheduler_SchedLock { friend class Cyg_HardwareThread; friend class Cyg_SchedThread; protected: // The following variables are implicit in the API, but are // not publically visible. // Current running thread static Cyg_Thread * volatile current_thread[CYGNUM_KERNEL_CPU_MAX] CYGBLD_ANNOTATE_VARIABLE_SCHED; // Set when reschedule needed static volatile cyg_bool need_reschedule[CYGNUM_KERNEL_CPU_MAX] CYGBLD_ANNOTATE_VARIABLE_SCHED; // Count of number of thread switches static volatile cyg_ucount32 thread_switches[CYGNUM_KERNEL_CPU_MAX] CYGBLD_ANNOTATE_VARIABLE_SCHED; public: // return a pointer to the current thread static Cyg_Thread *get_current_thread(); // Set current thread pointer static void set_current_thread(Cyg_Thread *thread); static void set_current_thread(Cyg_Thread *thread, HAL_SMP_CPU_TYPE cpu); // Set need_reschedule flag static void set_need_reschedule(); static void set_need_reschedule(Cyg_Thread *thread); // Get need_reschedule flag static cyg_bool get_need_reschedule(); // Return current value of lock static cyg_ucount32 get_sched_lock(); // Clear need_reschedule flag static void clear_need_reschedule(); // Return current number of thread switches static cyg_ucount32 get_thread_switches(); }; // ------------------------------------------------------------------------- // Include the scheduler implementation header #include CYGPRI_KERNEL_SCHED_IMPL_HXX // Do some checking that we have a consistent universe. #ifdef CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL # ifndef CYGIMP_THREAD_PRIORITY # error Priority inversion protocols will not work without priorities!!! # endif #endif // ------------------------------------------------------------------------- // Scheduler class. This is the public scheduler interface seen by the // rest of the kernel. class Cyg_Scheduler : public Cyg_Scheduler_Implementation { friend class Cyg_Thread; // This function is the actual implementation of the unlock // function. The unlock() later is an inline shell that deals // with the common case. static void unlock_inner(cyg_uint32 new_lock = 0); public: CYGDBG_DEFINE_CHECK_THIS // The following API functions are common to all scheduler // implementations. // claim the preemption lock static void lock(); // release the preemption lock and possibly reschedule static void unlock(); // release and reclaim the lock atomically, keeping the old // value on restart static void reschedule(); // decrement the lock but also look for a reschedule opportunity static void unlock_reschedule(); // release the preemption lock without rescheduling static void unlock_simple(); // perform thread startup housekeeping void thread_entry( Cyg_Thread *thread ); // Start execution of the scheduler static void start() CYGBLD_ATTRIB_NORET; // Start execution of the scheduler on the current CPU static void start_cpu() CYGBLD_ATTRIB_NORET; // The only scheduler instance should be this one... static Cyg_Scheduler scheduler CYGBLD_ANNOTATE_VARIABLE_SCHED; }; // ------------------------------------------------------------------------- // This class encapsulates the scheduling abstractions in a thread. // Cyg_SchedThread is included as a base class of Cyg_Thread. The actual // implementation of the abstractions is in Cyg_SchedThread_Implementation // so this class has little to do. class Cyg_SchedThread : public Cyg_SchedThread_Implementation { friend class Cyg_ThreadQueue_Implementation; friend class Cyg_Scheduler_Implementation; friend class Cyg_Scheduler; Cyg_ThreadQueue *queue; public: Cyg_SchedThread(Cyg_Thread *thread, CYG_ADDRWORD sched_info); // Return current queue pointer Cyg_ThreadQueue *get_current_queue(); // Remove this thread from current queue void remove(); #ifdef CYGSEM_KERNEL_SCHED_ASR_SUPPORT // ASR support. // An ASR is an Asynchronous Service Routine. When set pending it // is called when the thread exits the scheduler. ASRs are mainly // used by compatibility subsystems, such as POSIX, to implement // such things as thread cancellation and signal delivery. private: volatile cyg_ucount32 asr_inhibit; // If > 0, blocks calls to ASRs volatile cyg_bool asr_pending; // If true, this thread's ASR should be called. #ifdef CYGSEM_KERNEL_SCHED_ASR_GLOBAL static #endif Cyg_ASR *asr; // ASR function #ifdef CYGSEM_KERNEL_SCHED_ASR_DATA_GLOBAL static #endif CYG_ADDRWORD asr_data; // ASR data pointer // Default ASR function static void asr_default(CYG_ADDRWORD data); public: // Public interface to ASR mechanism // Set, clear and get inhibit flag. inline void set_asr_inhibit() { asr_inhibit++; } inline void clear_asr_inhibit() { asr_inhibit--; } inline cyg_ucount32 get_asr_inhibit() { return asr_inhibit; } // Set and get pending flag. The flag is only cleared when the // ASR is called. inline void set_asr_pending() { asr_pending = true; } inline cyg_bool get_asr_pending() { return asr_pending; } // Set a new ASR, returning the old one. void set_asr( Cyg_ASR *new_asr, CYG_ADDRWORD new_data, Cyg_ASR **old_asr, CYG_ADDRWORD *old_data); // Clear the ASR function back to the default. void clear_asr(); #else public: // Even when we do not have ASRs enabled, we keep these functions // available. This avoids excessive ifdefs in the rest of the // kernel code. inline void set_asr_inhibit() { } inline void clear_asr_inhibit() { } #endif #ifdef CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL private: // For all priority inversion protocols we need to keep track of how // many mutexes we have locked, including one which we are waiting to // lock, because we can inherit priority while sleeping just prior to // wakeup. cyg_count32 mutex_count; protected: // These are implementation functions that are common to all protocols. // Inherit the given priority. If thread is non-NULL the priority is // being inherited from it, otherwise it has come from the mutex. void set_inherited_priority( cyg_priority pri, Cyg_Thread *thread = 0 ); // Relay the priority of the ex-owner thread or from the queue if it // has a higher priority than ours. void relay_inherited_priority( Cyg_Thread *ex_owner, Cyg_ThreadQueue *pqueue); // Lose priority inheritance void clear_inherited_priority(); public: // Count and uncount the number of mutexes held by // this thread. void count_mutex() { mutex_count++; }; void uncount_mutex() { mutex_count--; }; #if defined(CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_SIMPLE) protected: // The simple priority inversion protocols simply needs // somewhere to store the base priority of the current thread. cyg_priority original_priority; // our original priority cyg_bool priority_inherited; // have we inherited? #endif #ifdef CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_INHERIT public: // Inherit the priority of the provided thread if it // has higher priority than this. void inherit_priority( Cyg_Thread *thread); // Relay the priority of the ex-owner thread or from the queue if it // has a higher priority than ours. void relay_priority( Cyg_Thread *ex_owner, Cyg_ThreadQueue *pqueue); // Lose priority inheritance void disinherit_priority(); #endif #ifdef CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_CEILING public: // Set the priority of this thread to the given ceiling. void set_priority_ceiling( cyg_priority pri ); // Clear the ceiling, if necessary. void clear_priority_ceiling(); #endif #endif }; // ------------------------------------------------------------------------- // Simple inline accessor functions inline Cyg_Thread *Cyg_Scheduler_Base::get_current_thread() { return current_thread[CYG_KERNEL_CPU_THIS()]; } inline void Cyg_Scheduler_Base::set_current_thread(Cyg_Thread *thread ) { current_thread[CYG_KERNEL_CPU_THIS()] = thread; } inline void Cyg_Scheduler_Base::set_current_thread(Cyg_Thread *thread, HAL_SMP_CPU_TYPE cpu) { current_thread[cpu] = thread; } inline cyg_bool Cyg_Scheduler_Base::get_need_reschedule() { return need_reschedule[CYG_KERNEL_CPU_THIS()]; } inline void Cyg_Scheduler_Base::set_need_reschedule() { need_reschedule[CYG_KERNEL_CPU_THIS()] = true; } inline void Cyg_Scheduler_Base::set_need_reschedule(Cyg_Thread *thread) { need_reschedule[CYG_KERNEL_CPU_THIS()] = true; } inline void Cyg_Scheduler_Base::clear_need_reschedule() { need_reschedule[CYG_KERNEL_CPU_THIS()] = false; } inline cyg_ucount32 Cyg_Scheduler_Base::get_sched_lock() { return Cyg_Scheduler_SchedLock::get_sched_lock(); } // Return current number of thread switches inline cyg_ucount32 Cyg_Scheduler_Base::get_thread_switches() { return thread_switches[CYG_KERNEL_CPU_THIS()]; } // Return current queue pointer inline Cyg_ThreadQueue *Cyg_SchedThread::get_current_queue() { return queue; } // ------------------------------------------------------------------------- #endif // ifndef __SCHED_HXX__ // EOF sched.hxx