Ticket #1743: Simple.diff

cpukit/sapi/include/confdefs.h

@@ -556 +556 @@
  * scheduling policy to use.  The supported configurations are:
  *  CONFIGURE_SCHEDULER_USER     - user provided scheduler
  *  CONFIGURE_SCHEDULER_PRIORITY - Deterministic Priority Scheduler
+ *  CONFIGURE_SCHEDULER_SIMPLE   - Light-weight Priority Scheduler
  * 
  * If no configuration is specified by the application, then 
  * CONFIGURE_SCHEDULER_PRIORITY is assumed to be the default.
@@ -575 +576 @@
 
 /* If no scheduler is specified, the priority scheduler is default. */
 #if !defined(CONFIGURE_SCHEDULER_USER) && \
-    !defined(CONFIGURE_SCHEDULER_PRIORITY)
+    !defined(CONFIGURE_SCHEDULER_PRIORITY) && \
+    !defined(CONFIGURE_SCHEDULER_SIMPLE)
   #define CONFIGURE_SCHEDULER_PRIORITY
 #endif
 
 /* 
- * Is the Priority Scheduler is selected, then configure for it.
+ * If the Priority Scheduler is selected, then configure for it.
  */
 #if defined(CONFIGURE_SCHEDULER_PRIORITY)
   #include <rtems/score/schedulerpriority.h>
@@ -598 +600 @@
 #endif
 
 /* 
+ * If the Simple Priority Scheduler is selected, then configure for it.
+ */
+#if defined(CONFIGURE_SCHEDULER_SIMPLE)
+  #include <rtems/score/schedulersimple.h>
+  #define SCHEDULER_ENTRY_POINTS SCHEDULER_SIMPLE_ENTRY_POINTS
+
+  /**
+   * define the memory used by the simple scheduler
+   */
+  #define CONFIGURE_MEMORY_FOR_SCHEDULER ( \
+    _Configure_From_workspace( sizeof(Chain_Control) ) \
+  )
+  #define CONFIGURE_MEMORY_PER_TASK_FOR_SCHEDULER (0)
+#endif
+
+/* 
  * Set up the scheduler entry points table.  The scheduling code uses
  * this code to know which scheduler is configured by the user.
  */

cpukit/score/Makefile.am

@@ -27 +27 @@
     include/rtems/score/object.h include/rtems/score/percpu.h \
     include/rtems/score/priority.h include/rtems/score/prioritybitmap.h \
     include/rtems/score/scheduler.h include/rtems/score/schedulerpriority.h \
+    include/rtems/score/schedulersimple.h \
     include/rtems/score/stack.h include/rtems/score/states.h \
     include/rtems/score/sysstate.h include/rtems/score/thread.h \
     include/rtems/score/threadq.h include/rtems/score/threadsync.h \
@@ -56 +57 @@
     inline/rtems/score/isr.inl inline/rtems/score/object.inl \
     inline/rtems/score/priority.inl inline/rtems/score/prioritybitmap.inl \
     inline/rtems/score/scheduler.inl inline/rtems/score/schedulerpriority.inl \
+    inline/rtems/score/schedulersimple.inl \
     inline/rtems/score/stack.inl inline/rtems/score/states.inl \
     inline/rtems/score/sysstate.inl inline/rtems/score/thread.inl \
     inline/rtems/score/threadq.inl inline/rtems/score/tod.inl \
@@ -155 +157 @@
     src/schedulerpriorityupdate.c \
     src/schedulerpriorityyield.c
 
+## SCHEDULERSIMPLE_C_FILES
+libscore_a_SOURCES += src/schedulersimple.c \
+    src/schedulersimpleblock.c \
+    src/schedulersimpleenqueue.c \
+    src/schedulersimpleenqueuefirst.c \
+    src/schedulersimpleextract.c \
+    src/schedulersimpleschedule.c \
+    src/schedulersimpleunblock.c \
+    src/schedulersimpleyield.c 
+
 ## PROTECTED_HEAP_C_FILES
 libscore_a_SOURCES += src/pheapallocate.c \
     src/pheapextend.c src/pheapfree.c src/pheapgetsize.c \

cpukit/score/preinstall.am

@@ -119 +119 @@
         $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/rtems/score/schedulerpriority.h
 PREINSTALL_FILES += $(PROJECT_INCLUDE)/rtems/score/schedulerpriority.h
 
+$(PROJECT_INCLUDE)/rtems/score/schedulersimple.h: include/rtems/score/schedulersimple.h $(PROJECT_INCLUDE)/rtems/score/$(dirstamp)
+        $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/rtems/score/schedulersimple.h
+PREINSTALL_FILES += $(PROJECT_INCLUDE)/rtems/score/schedulersimple.h
+
 $(PROJECT_INCLUDE)/rtems/score/stack.h: include/rtems/score/stack.h $(PROJECT_INCLUDE)/rtems/score/$(dirstamp)
         $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/rtems/score/stack.h
 PREINSTALL_FILES += $(PROJECT_INCLUDE)/rtems/score/stack.h
@@ -261 +265 @@
         $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/rtems/score/schedulerpriority.inl
 PREINSTALL_FILES += $(PROJECT_INCLUDE)/rtems/score/schedulerpriority.inl
 
+$(PROJECT_INCLUDE)/rtems/score/schedulersimple.inl: inline/rtems/score/schedulersimple.inl $(PROJECT_INCLUDE)/rtems/score/$(dirstamp)
+        $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/rtems/score/schedulersimple.inl
+PREINSTALL_FILES += $(PROJECT_INCLUDE)/rtems/score/schedulersimple.inl
+
 $(PROJECT_INCLUDE)/rtems/score/stack.inl: inline/rtems/score/stack.inl $(PROJECT_INCLUDE)/rtems/score/$(dirstamp)
         $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/rtems/score/stack.inl
 PREINSTALL_FILES += $(PROJECT_INCLUDE)/rtems/score/stack.inl

cpukit/score/include/rtems/score/schedulerpriority.h

@@ -170 +170 @@
   Thread_Control     *the_thread
 );
 
+/**
+ *  This is the major bit map.
+ */
+extern volatile Priority_bit_map_Control _Priority_Major_bit_map;
+
+/**
+ *  This is the minor bit map.
+ */
+extern Priority_bit_map_Control _Priority_Bit_map[16] CPU_STRUCTURE_ALIGNMENT;
+
 #ifndef __RTEMS_APPLICATION__
 #include <rtems/score/schedulerpriority.inl>
 #endif

new file cpukit/score/include/rtems/score/schedulersimple.h

@@ +1 @@
+/**
+ *  @file  rtems/score/schedulersimple.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the manipulation of threads on a simple-priority-based ready queue.
+ */
+
+#ifndef _RTEMS_SCORE_SCHEDULERSIMPLE_H
+#define _RTEMS_SCORE_SCHEDULERSIMPLE_H
+
+/**
+ *  @addtogroup ScoreScheduler
+ *
+ */
+/**@{*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/score/scheduler.h>
+
+/**
+ *  Entry points for Scheduler Simple
+ */
+#define SCHEDULER_SIMPLE_ENTRY_POINTS \
+  { \
+    _Scheduler_simple_Initialize,    /* initialize entry point */ \
+    _Scheduler_simple_Schedule,      /* schedule entry point */ \
+    _Scheduler_simple_Yield,         /* yield entry point */ \
+    _Scheduler_simple_Block,         /* block entry point */ \
+    _Scheduler_simple_Unblock,       /* unblock entry point */ \
+    _Scheduler_simple_Allocate,      /* allocate entry point */ \
+    _Scheduler_simple_Free,          /* free entry point */ \
+    _Scheduler_simple_Update,        /* update entry point */ \
+    _Scheduler_simple_Enqueue,       /* enqueue entry point */ \
+    _Scheduler_simple_Enqueue_first, /* enqueue_first entry point */ \
+    _Scheduler_priorisimple_t        /* extract entry point */ \
+  }
+
+/**
+ * This routine initializes the simple scheduler.
+ */
+void _Scheduler_simple_Initialize( void );
+
+/**
+ *  This routine sets the heir thread to be the next ready thread 
+ *  on the ready queue by getting the first node in the scheduler
+ *  information.
+ */
+void _Scheduler_simple_Schedule( void );
+
+/**
+ *  This routine is invoked when a thread wishes to voluntarily
+ *  transfer control of the processor to another thread in the queue.
+ *  It will remove the running THREAD from the scheduler.informaiton 
+ *  (where the ready queue is stored) and place it immediately at the 
+ *  between the last entry of its priority and the next priority thread.  
+ *  Reset timeslice and yield the processor functions both use this routine, 
+ *  therefore if reset is true and this is the only thread on the queue then 
+ *  the timeslice counter is reset.  The heir THREAD will be updated if the
+ *  running is also the currently the heir.
+*/
+void _Scheduler_simple_Yield( void );
+
+/**
+ *  This routine removes @a the_thread from the scheduling decision, 
+ *  that is, removes it from the ready queue.  It performs
+ *  any necessary scheduling operations including the selection of
+ *  a new heir thread.
+ *
+ *  XXX
+ */
+void _Scheduler_simple_Block( 
+  Thread_Control *the_thread 
+);
+
+/**
+ *  This routine adds @a the_thread to the scheduling decision, 
+ *  that is, adds it to the ready queue and 
+ *  updates any appropriate scheduling variables, for example the heir thread.
+ *
+ *  XXX
+ */
+void _Scheduler_simple_Unblock(
+  Thread_Control *the_thread 
+);
+
+/**
+ *  This routine removes a specific thread from the specified 
+ *  simple-based ready queue.
+ *
+ *  @param[in] the_thread is the thread to be blocked
+ */
+void _Scheduler_simple_Extract(
+  Thread_Control    *the_thread
+);
+
+/**
+ *  This routine puts @a the_thread on to the ready queue.
+ *
+ *  @param[in] the_thread is the thread to be blocked
+ */
+void _Scheduler_simple_Enqueue(
+  Thread_Control            *the_thread
+);
+
+/**
+ *  This routine puts @a the_thread to the head of the ready queue. 
+ *  The thread will be the first thread at its priority level.
+ *
+ *  @param[in] the_thread is the thread to be blocked
+ */
+void _Scheduler_simple_Enqueue_first(
+  Thread_Control            *the_thread
+);
+
+/**
+ * This routine allocates the ready queue information.
+ *
+ *  @param[in] the_thread is the thread to be blocked
+ */
+void * _Scheduler_simple_Allocate( 
+  Thread_Control *the_thread
+);
+
+/**
+ * This routine does nothing, and is used as a stub for Sched_update
+ *
+ * The overhead of a function call will still be imposed. :(
+ *
+ *  @param[in] the_thread is the thread to be blocked
+ */
+void _Scheduler_simple_Update( 
+  Thread_Control *the_thread
+);
+
+/**
+ * This routine does nothing, and is used as a stub for Sched_free
+ *
+ * The overhead of a function call will still be imposed. :(
+ *
+ *  @param[in] the_thread is the thread to be blocked
+ */
+void _Scheduler_simple_Free( 
+  Thread_Control *the_thread
+);
+
+#ifndef __RTEMS_APPLICATION__
+#include <rtems/score/schedulersimple.inl>
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+/**@}*/
+
+#endif
+/* end of include file */

new file cpukit/score/inline/rtems/score/schedulersimple.inl

@@ +1 @@
+/** 
+ *  @file  rtems/score/schedulersimple.inl
+ *
+ *  This inline file contains all of the inlined routines associated with
+ *  the manipulation of the priority-based scheduling structures.
+ */
+
+/*
+ *  Copyright (C) 2011 On-Line Applications Research Corporation (OAR).
+ *
+ *  The license and distribution terms for this file may be
+ *  found in the file LICENSE in this distribution or at
+ *  http://www.rtems.com/license/LICENSE.
+ *
+ *  $Id$
+ */
+
+#ifndef _RTEMS_SCORE_SCHEDULERSIMPLE_H
+# error "Never use <rtems/score/schedulersimple.inl> directly; include <rtems/score/schedulersimple.h> instead."
+#endif
+
+#ifndef _RTEMS_SCORE_SCHEDULERSIMPLE_INL
+#define _RTEMS_SCORE_SCHEDULERSIMPLE_INL
+
+#include <rtems/score/thread.h>
+
+/**
+ *  @addtogroup ScoreScheduler
+ * @{
+ */
+
+/**
+ *  _Scheduler_simple_Ready_queue_Enqueue
+ *
+ *  This routine puts @a the_thread on the ready queue
+ *  at the end of its priority group.
+ *  
+ *  @param[in] the_thread - pointer to a thread control block
+ */
+RTEMS_INLINE_ROUTINE void _Scheduler_simple_Ready_queue_Enqueue(
+  Thread_Control    *the_thread
+)
+{
+  Chain_Control    *ready;
+  Chain_Node       *the_node;
+  Thread_Control   *current;
+
+  ready    = (Chain_Control *)_Scheduler.information;
+  the_node = _Chain_First( ready );
+  current  = (Thread_Control *)ready;
+
+  for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
+    current = (Thread_Control *) the_node;
+
+    /* break when AT END OR PAST our priority */
+    if ( the_thread->current_priority < current->current_priority ) {
+      current = (Thread_Control *)current->Object.Node.previous;
+      break;
+    }
+  }
+
+  /* enqueue */
+  _Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
+}
+
+/**
+ *  _Scheduler_simple_Ready_queue_Enqueue_first
+ *
+ *  This routine puts @a the_thread on to the ready queue
+ *  at the beginning of its priority group.
+ *  
+ *  @param[in] the_thread - pointer to a thread control block
+ */
+RTEMS_INLINE_ROUTINE void _Scheduler_simple_Ready_queue_Enqueue_first(
+  Thread_Control    *the_thread
+)
+{
+  Chain_Control    *ready;
+  Chain_Node       *the_node;
+  Thread_Control   *current;
+
+  ready    = (Chain_Control *)_Scheduler.information;
+  the_node = _Chain_First( ready );
+  current  = (Thread_Control *)ready;
+
+  for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
+    current = (Thread_Control *) the_node;
+
+    /* break when AT HEAD OF (or PAST) our priority */
+    if ( the_thread->current_priority <= current->current_priority ) {
+      current = (Thread_Control *)current->Object.Node.previous;
+      break;
+    }
+  }
+
+  /* enqueue */
+  _Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
+}
+
+
+/* 
+ *  _Scheduler_simple_Ready_queue_Requeue
+ *
+ *  This routine puts @a the_thread on to the priority-based ready queue.
+ *  
+ *  Input parameters:
+ *    the_ready_queue - pointer to a readyq header
+ *    the_thread       - pointer to a thread control block
+ *
+ *  Output parameters: NONE
+ *
+ *  INTERRUPT LATENCY: NONE
+ */
+RTEMS_INLINE_ROUTINE void _Scheduler_simple_Ready_queue_Requeue(
+  Scheduler_Control *the_ready_queue,
+  Thread_Control    *the_thread
+)
+{
+  /* extract */
+  _Chain_Extract_unprotected( &the_thread->Object.Node );
+
+  /* enqueue */
+  _Scheduler_simple_Ready_queue_Enqueue( the_thread );
+}
+
+/**@}*/
+
+#endif
+/* end of include file */

cpukit/score/src/schedulerpriority.c

@@ -29 +29 @@
 void _Scheduler_priority_Initialize(void)
 {
   _Scheduler_priority_Ready_queue_initialize();
-  _Priority_bit_map_Handler_initialization( );
+  _Priority_bit_map_Handler_initialization();
 }

cpukit/score/src/schedulerpriorityextract.c

@@ -1 @@
-/*
+/*  Scheduler Simple Handler / Extract
+ *
  *  COPYRIGHT (c) 2011.
  *  On-Line Applications Research Corporation (OAR).
  *
@@ -22 +23 @@
   Thread_Control      *the_thread
 )
 {
-   _Scheduler_priority_Ready_queue_extract( the_thread );
+  _Scheduler_priority_Ready_queue_extract( the_thread );
 }

cpukit/score/src/schedulerpriorityupdate.c

@@ -33 +33 @@
   sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info;
   rq         = (Chain_Control *) _Scheduler.information;
 
-
   sched_info->ready_chain = &rq[ the_thread->current_priority ];
 
   _Priority_bit_map_Initialize_information( 

new file cpukit/score/src/schedulersimple.c

@@ +1 @@
+/*
+ *  Scheduler Simple Handler / Initialize
+ *  Scheduler Simple Handler / Allocate (Empty Routine)
+ *  Scheduler Simple Handler / Update (Empty Routine)
+ *  Scheduler Simple Handler / Free (Empty Routine)
+ *
+ *  COPYRIGHT (c) 2011.
+ *  On-Line Applications Research Corporation (OAR).
+ *
+ *  The license and distribution terms for this file may be
+ *  found in the file LICENSE in this distribution or at
+ *  http://www.rtems.com/license/LICENSE.
+ *
+ *  $Id$
+ */
+
+#if HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <rtems/system.h>
+#include <rtems/config.h>
+#include <rtems/score/chain.h>
+#include <rtems/score/scheduler.h>
+#include <rtems/score/schedulersimple.h>
+#include <rtems/score/thread.h>
+#include <rtems/score/wkspace.h>
+
+/**
+ * This routine does nothing, and is used as a stub for Sched_allocate
+ *
+ * Note: returns a non-zero value, or else thread initialize thinks the 
+ * allocation failed.
+ *
+ * The overhead of a function call will still be imposed. :(
+ */
+void * _Scheduler_simple_Allocate( 
+  Thread_Control *the_thread
+)
+{
+  return (void*)-1; /* maybe pick an appropriate poison value */
+}
+
+
+/**
+ * This routine does nothing, and is used as a stub for Sched_update
+ *
+ * The overhead of a function call will still be imposed. :(
+ */
+void _Scheduler_simple_Update( 
+  Thread_Control *the_thread
+)
+{
+}
+
+/**
+ * This routine does nothing, and is used as a stub for Sched_free
+ *
+ * The overhead of a function call will still be imposed. :(
+ */
+void _Scheduler_simple_Free( 
+  Thread_Control *the_thread
+)
+{
+}
+
+/*
+ *  _Scheduler_simple_Initialize
+ *
+ *  Initializes the scheduler for simple scheduling.
+ *
+ *  Input parameters:  NONE
+ *
+ *  Output parameters: NONE
+ */
+void _Scheduler_simple_Initialize ( void )
+{
+  void *f;
+
+  /* 
+   * Initialize Ready Queue
+   */
+
+  /* allocate ready queue structures */
+  f = _Workspace_Allocate_or_fatal_error( sizeof(Chain_Control) );
+  _Scheduler.information = f;
+
+  /* initialize ready queue structure */
+  _Chain_Initialize_empty( (Chain_Control *)f );
+}

new file cpukit/score/src/schedulersimpleblock.c

@@ +1 @@
+/*
+ *  Scheduler Simple Handler / Block
+ *
+ *  COPYRIGHT (c) 2011.
+ *  On-Line Applications Research Corporation (OAR).
+ *
+ *  The license and distribution terms for this file may be
+ *  found in found in the file LICENSE in this distribution or at
+ *  http://www.rtems.com/license/LICENSE.
+ *
+ *  $Id$
+ */
+
+#if HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <rtems/system.h>
+#include <rtems/score/context.h>
+#include <rtems/score/interr.h>
+#include <rtems/score/isr.h>
+#include <rtems/score/object.h>
+#include <rtems/score/priority.h>
+#include <rtems/score/scheduler.h>
+#include <rtems/score/thread.h>
+#include <rtems/score/schedulersimple.h>
+
+void _Scheduler_simple_Block(
+  Thread_Control   *the_thread
+)
+{
+  _Scheduler_simple_Extract(the_thread);
+
+  /* TODO: flash critical section */
+  /* XXX */
+
+  /* TODO: Is this robust? */
+  if ( _Thread_Is_heir( the_thread ) )
+    _Scheduler_simple_Schedule();
+
+  if ( _Thread_Is_executing( the_thread ) )
+    _Thread_Dispatch_necessary = true;
+}

new file cpukit/score/src/schedulersimpleenqueue.c

@@ +1 @@
+/*
+ *  Schedule Simple Handler / Enqueue
+ *
+ *  COPYRIGHT (c) 2011.
+ *  On-Line Applications Research Corporation (OAR).
+ *
+ *  The license and distribution terms for this file may be
+ *  found in the file LICENSE in this distribution or at
+ *  http://www.rtems.com/license/LICENSE.
+ *
+ *  $Id$
+ */
+
+#if HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <rtems/system.h>
+#include <rtems/score/chain.h>
+#include <rtems/score/isr.h>
+#include <rtems/score/thread.h>
+#include <rtems/score/schedulersimple.h>
+
+void _Scheduler_simple_Enqueue(
+  Thread_Control            *the_thread
+)
+{
+  _Scheduler_simple_Ready_queue_Enqueue( the_thread );
+}

new file cpukit/score/src/schedulersimpleenqueuefirst.c

@@ +1 @@
+/*
+ *  Schedule Simple Handler / Enqueue First
+ *
+ *  COPYRIGHT (c) 2011.
+ *  On-Line Applications Research Corporation (OAR).
+ *
+ *  The license and distribution terms for this file may be
+ *  found in the file LICENSE in this distribution or at
+ *  http://www.rtems.com/license/LICENSE.
+ *
+ *  $Id$
+ */
+
+#if HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <rtems/system.h>
+#include <rtems/score/chain.h>
+#include <rtems/score/thread.h>
+#include <rtems/score/schedulersimple.h>
+
+void _Scheduler_simple_Enqueue_first(
+  Thread_Control            *the_thread
+)
+{
+  _Scheduler_simple_Ready_queue_Enqueue_first( the_thread );
+}

new file cpukit/score/src/schedulersimpleextract.c

@@ +1 @@
+/*
+ *  Schedule Simple Handler / Extract 
+ *
+ *  COPYRIGHT (c) 2011.
+ *  On-Line Applications Research Corporation (OAR).
+ *
+ *  The license and distribution terms for this file may be
+ *  found in the file LICENSE in this distribution or at
+ *  http://www.rtems.com/license/LICENSE.
+ *
+ *  $Id$
+ */
+
+#if HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <rtems/system.h>
+#include <rtems/score/chain.h>
+#include <rtems/score/thread.h>
+#include <rtems/score/schedulersimple.h>
+
+void _Scheduler_simple_Extract(
+  Thread_Control    *the_thread
+)
+{
+  _Chain_Extract_unprotected( &the_thread->Object.Node );
+}

new file cpukit/score/src/schedulersimpleschedule.c

@@ +1 @@
+/*
+ *  Scheduler Simple Handler / Schedule
+ *
+ *  COPYRIGHT (c) 2011.
+ *  On-Line Applications Research Corporation (OAR).
+ *
+ *  The license and distribution terms for this file may be
+ *  found in found in the file LICENSE in this distribution or at
+ *  http://www.rtems.com/license/LICENSE.
+ *
+ *  $Id$
+ */
+
+#if HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <rtems/system.h>
+#include <rtems/score/context.h>
+#include <rtems/score/interr.h>
+#include <rtems/score/isr.h>
+#include <rtems/score/object.h>
+#include <rtems/score/priority.h>
+#include <rtems/score/percpu.h>
+#include <rtems/score/scheduler.h>
+#include <rtems/score/thread.h>
+#include <rtems/score/schedulersimple.h>
+
+void _Scheduler_simple_Schedule(void)
+{
+  _Thread_Heir = (Thread_Control *) _Chain_First( 
+    (Chain_Control *) _Scheduler.information 
+  );
+}

new file cpukit/score/src/schedulersimpleunblock.c

@@ +1 @@
+/*
+ *  Scheduler Simple Handler / Unblock
+ *
+ *  COPYRIGHT (c) 2011.
+ *  On-Line Applications Research Corporation (OAR).
+ *
+ *  The license and distribution terms for this file may be
+ *  found in found in the file LICENSE in this distribution or at
+ *  http://www.rtems.com/license/LICENSE.
+ *
+ *  $Id$
+ */
+
+#if HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <rtems/system.h>
+#include <rtems/score/isr.h>
+#include <rtems/score/schedulersimple.h>
+#include <rtems/score/thread.h>
+
+void _Scheduler_simple_Unblock(
+  Thread_Control    *the_thread
+)
+{
+  _Scheduler_simple_Ready_queue_Enqueue(the_thread);
+
+  /* TODO: flash critical section? */
+
+  /*
+   *  If the thread that was unblocked is more important than the heir,
+   *  then we have a new heir.  This may or may not result in a
+   *  context switch.
+   *
+   *  Normal case:
+   *    If the current thread is preemptible, then we need to do
+   *    a context switch.
+   *  Pseudo-ISR case:
+   *    Even if the thread isn't preemptible, if the new heir is
+   *    a pseudo-ISR system task, we need to do a context switch.
+   */
+  if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
+    _Thread_Heir = the_thread;
+    if ( _Thread_Executing->is_preemptible ||
+        the_thread->current_priority == 0 )
+      _Thread_Dispatch_necessary = true;
+  }
+}

new file cpukit/score/src/schedulersimpleyield.c

@@ +1 @@
+/*
+ *  Scheduler Simple Handler / Yield
+ *
+ *  COPYRIGHT (c) 2011.
+ *  On-Line Applications Research Corporation (OAR).
+ *
+ *  The license and distribution terms for this file may be
+ *  found in found in the file LICENSE in this distribution or at
+ *  http://www.rtems.com/license/LICENSE.
+ *
+ *  $Id$
+ */
+
+#if HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <rtems/system.h>
+#include <rtems/score/isr.h>
+#include <rtems/score/scheduler.h>
+#include <rtems/score/thread.h>
+#include <rtems/score/schedulersimple.h>
+
+void _Scheduler_simple_Yield( void )
+{
+  ISR_Level       level;
+  Thread_Control *executing;
+
+  executing = _Thread_Executing;
+  _ISR_Disable( level );
+      
+    _Scheduler_simple_Ready_queue_Requeue(&_Scheduler, executing);
+
+    _ISR_Flash( level );
+
+    _Scheduler_simple_Schedule();
+    
+    if ( !_Thread_Is_heir( executing ) )
+      _Thread_Dispatch_necessary = true;
+
+  _ISR_Enable( level );
+}

testsuites/sptests/spsize/size.c

@@ -72 +72 @@
 #define  HEAP_OVHD        16    /* wasted heap space per task stack */
 #define  NAME_PTR_SIZE     8    /* size of name and pointer table entries */
 
-#if CONFIGURE_SCHEDULER_POLICY == _Scheduler_PRIORITY
-  #include <rtems/score/prioritybitmap.h>
+/*
+ *  This assumes the default Priority Scheduler
+ */
+#include <rtems/score/prioritybitmap.h>
+#include <rtems/score/schedulerpriority.h>
+
+/* Priority scheduling uninitialized (globals) consumption */
+#define SCHEDULER_OVHD     ((sizeof _Scheduler)              + \
+                           (sizeof _Priority_Major_bit_map) + \
+                           (sizeof _Priority_Bit_map))
+
+/* Priority scheduling per-thread consumption. Gets 
+ * included in the PER_TASK consumption.
+ */
+#define SCHEDULER_TASK_WKSP     (sizeof(Scheduler_priority_Per_thread))
 
-  /* Priority scheduling uninitialized (globals) consumption */
-  #define SCHEDULER_OVHD          ((sizeof _Scheduler)              + \
-                                   (sizeof _Priority_Major_bit_map) + \
-                                   (sizeof _Priority_Bit_map))
-
-  /* Priority scheduling per-thread consumption. Gets 
-   * included in the PER_TASK consumption. */
-  #define SCHEDULER_TASK_WKSP     (sizeof(Scheduler_priority_Per_thread))
-
-  /* Priority scheduling workspace consumption 
-   *
-   * Include allocation of ready queue.  Pointers are already counted by 
-   * including _Scheduler in SCHEDULER_OVHD.
-   */
-  #define  SCHEDULER_WKSP_SIZE  \
+/* Priority scheduling workspace consumption 
+ *
+ * Include allocation of ready queue.  Pointers are already counted by 
+ * including _Scheduler in SCHEDULER_OVHD.
+ */
+#define SCHEDULER_WKSP_SIZE  \
     ((RTEMS_MAXIMUM_PRIORITY + 1) * sizeof(Chain_Control ))
-#endif
+/****** END OF MEMORY USAGE OF DEFAULT PRIORITY SCHEDULER ******/
 
 #define PER_TASK      \
      (long) (sizeof (Thread_Control) + \

testsuites/tmtests/tm26/task1.c

@@ -102 +102 @@
 
   puts( "\n\n*** TIME TEST 26 ***" );
 
+  if (_Scheduler.Operations.initialize != _Scheduler_priority_Initialize) {
+    puts("     Error ==> Test only supported for deterministic priority scheduler\n" );
+    puts( "*** END OF TEST 26 ***" );
+    rtems_test_exit( 0 );
+  }
+
 #define FP1_PRIORITY (RTEMS_MAXIMUM_PRIORITY - 3u)      /* 201, */
   status = rtems_task_create(
     rtems_build_name( 'F', 'P', '1', ' ' ),

testsuites/tmtests/tm27/task1.c

@@ -54 +54 @@
   Print_Warning();
 
   puts( "\n\n*** TIME TEST 27 ***" );
+  if (_Scheduler.Operations.initialize != _Scheduler_priority_Initialize) {
+    puts("     Error ==> Test only supported for deterministic priority scheduler\n" );
+    puts( "*** END OF TEST 26 ***" );
+    rtems_test_exit( 0 );
+  }
 
 #define LOW_PRIORITY (RTEMS_MAXIMUM_PRIORITY - 1u)
   status = rtems_task_create(