Ticket #1808: per_core_scheduler_updated.patch

cpukit/sapi/include/confdefs.h

@@ -573 +573 @@
  *  CONFIGURE_SCHEDULER_PRIORITY   - Deterministic Priority Scheduler
  *  CONFIGURE_SCHEDULER_SIMPLE     - Light-weight Priority Scheduler
  *  CONFIGURE_SCHEDULER_SIMPLE_SMP - Simple SMP Priority Scheduler
+ *  CONFIGURE_SCHEDULER_PERCORE_SMP - PerCore SMP Scheduler
  * 
  * If no configuration is specified by the application, then 
  * CONFIGURE_SCHEDULER_PRIORITY is assumed to be the default.
@@ -592 +593 @@
 
 #if !defined(RTEMS_SMP)
   #undef CONFIGURE_SCHEDULER_SIMPLE_SMP
+  #undef CONFIGURE_SCHEDULER_PERCORE_SMP
 #endif
 
 /* If no scheduler is specified, the priority scheduler is default. */
@@ -640 +642 @@
   #define CONFIGURE_MEMORY_PER_TASK_FOR_SCHEDULER (0)
 #endif
 
+/* 
+ * If the PerCore SMP Scheduler is selected, then configure for it.
+ */
+#if defined(CONFIGURE_SCHEDULER_PERCORE_SMP)
+  #include <rtems/score/schedulerpercoresmp.h>
+  #define CONFIGURE_SCHEDULER_ENTRY_POINTS SCHEDULER_PERCORE_SMP_ENTRY_POINTS
+
+  /**
+   * define the memory used by the SMP simple scheduler
+   */
+  #define CONFIGURE_MEMORY_FOR_SCHEDULER ( \
+    CONFIGURE_SMP_MAXIMUM_PROCESSORS * _Configure_From_workspace( sizeof(Scheduler_PerCore_SMP_Information) ) \
+      )
+  #define CONFIGURE_MEMORY_PER_TASK_FOR_SCHEDULER (0)
+#endif
+
 /*
  * If the Simple SMP Priority Scheduler is selected, then configure for it.
  */
@@ -663 +681 @@
           CONFIGURE_SCHEDULER_USER_ENTRY_POINTS
 #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

@@ -78 +78 @@
 
 if HAS_SMP
 include_rtems_score_HEADERS += include/rtems/score/schedulersimplesmp.h
+include_rtems_score_HEADERS += include/rtems/score/schedulerpercoresmp.h
 endif
 
 ## inline
@@ -218 +219 @@
     src/schedulersimpleunblock.c \
     src/schedulersimpleyield.c 
 
+if HAS_SMP
+## SCHEDULERPERCORESMP_C_FILES
+libscore_a_SOURCES += src/schedulerpercoresmp.c \
+    src/schedulerpercoresmpblock.c \
+    src/schedulerpercoresmpenqueue.c \
+    src/schedulerpercoresmpenqueuefirst.c \
+    src/schedulerpercoresmpextract.c \
+    src/schedulerpercoresmpreadyqueueenqueue.c \
+    src/schedulerpercoresmpreadyqueueenqueuefirst.c \
+    src/schedulerpercoresmpschedule.c \
+    src/schedulerpercoresmpunblock.c \
+    src/schedulerpercoresmpyield.c 
+endif
+
 ## PROTECTED_HEAP_C_FILES
 libscore_a_SOURCES += src/pheapallocate.c \
     src/pheapextend.c src/pheapfree.c src/pheapgetsize.c \

cpukit/score/include/rtems/score/percpu.h

@@ -143 +143 @@
 
   /** This is set to true when this CPU needs to run the dispatcher. */
   volatile bool dispatch_necessary;
+  
+  /** Scheduler-specific information */
+  void *scheduler_information;
 
   /** This is the time of the last context switch on this CPU. */
   Timestamp_Control time_of_last_context_switch;
+  
+  
 } Per_CPU_Control;
 #endif
 

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

@@ +1 @@
+/**
+ *  @file  rtems/score/schedulerpercoresmp.h
+ *
+ *  This include file contains all the constants and structures associated
+ *  with the manipulation of threads on a SMP-aware simple-priority-based ready queue.
+ *
+ *
+ *  Copyright (C) 2011 On-Line Applications Research Corporation (OAR).
+ *  Copyright (C) 2011 Kalray
+ *
+ *  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_SCHEDULERPERCORESMP_H
+#define _RTEMS_SCORE_SCHEDULERPERCORESMP_H
+
+#if defined(RTEMS_SMP)
+
+/**
+ *  @addtogroup ScoreScheduler
+ *
+ */
+/**@{*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtems/score/scheduler.h>
+
+/**
+ *  Entry points for PerCore SMP Scheduler
+ */
+#define SCHEDULER_PERCORE_SMP_ENTRY_POINTS \
+  { \
+    _Scheduler_PerCore_SMP_Initialize,    /* initialize entry point */ \
+    _Scheduler_PerCore_SMP_Schedule,      /* schedule entry point */ \
+    _Scheduler_PerCore_SMP_Yield,         /* yield entry point */ \
+    _Scheduler_PerCore_SMP_Block,         /* block entry point */ \
+    _Scheduler_PerCore_SMP_Unblock,       /* unblock entry point */ \
+    _Scheduler_PerCore_SMP_Allocate,      /* allocate entry point */ \
+    _Scheduler_PerCore_SMP_Free,          /* free entry point */ \
+    _Scheduler_PerCore_SMP_Update,        /* update entry point */ \
+    _Scheduler_PerCore_SMP_Enqueue,       /* enqueue entry point */ \
+    _Scheduler_PerCore_SMP_Enqueue_first, /* enqueue_first entry point */ \
+    _Scheduler_PerCore_SMP_Extract        /* extract entry point */ \
+  }
+  
+/**
+ * This is the scheduler-specific per-core information.
+ */
+typedef struct {
+    /** This element is used to lock this structure */
+    SMP_lock_spinlock_simple_Control lock; 
+    
+    /** Ready queue */
+    Chain_Control rq;
+} Scheduler_PerCore_SMP_Information;
+
+/**
+ * This routine initializes the simple scheduler.
+ */
+void _Scheduler_PerCore_SMP_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. Protecting wrapper of 
+ *  _Scheduler_PerCore_SMP_Schedule_unprotected.
+ */
+void _Scheduler_PerCore_SMP_Schedule( 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. This version is for internal use only.
+ */
+void _Scheduler_PerCore_SMP_Schedule_unprotected(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_PerCore_SMP_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.
+ *
+ *  @param[in] the_thread is the thread that is to be blocked
+ */
+void _Scheduler_PerCore_SMP_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.
+ *
+ *  @param[in] the_thread is the thread that is to be unblocked
+ */
+void _Scheduler_PerCore_SMP_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_PerCore_SMP_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_PerCore_SMP_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_PerCore_SMP_Enqueue_first(
+  Thread_Control *the_thread
+);
+
+/**
+ *  This routine is a place holder for any memeory allocation needed
+ *  by the scheduler.  For the simple scheduler the routine is an empty
+ *  place holder.
+ *
+ *  @param[in] the_thread is the thread the scheduler is allocating
+ *             management memory for
+ *
+ *  @return this routine returns -1 since this is just an empty placeholder
+ *  and the return value may be defined differently by each scheduler.
+ */
+void *_Scheduler_PerCore_SMP_Allocate( 
+  Thread_Control *the_thread
+);
+
+/**
+ * This routine does nothing, and is used as a stub for Schedule update
+ *
+ * The overhead of a function call will still be imposed.
+ *
+ *  @param[in] the_thread is the thread to be blocked
+ */
+void _Scheduler_PerCore_SMP_Update( 
+  Thread_Control *the_thread
+);
+
+/**
+ * This routine does nothing, and is used as a stub for Schedule free
+ *
+ * The overhead of a function call will still be imposed.
+ *
+ *  @param[in] the_thread is the thread to be blocked
+ */
+void _Scheduler_PerCore_SMP_Free( 
+  Thread_Control *the_thread
+);
+
+/**
+ *  _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
+ */
+void _Scheduler_PerCore_SMP_Ready_queue_Enqueue(
+  Thread_Control    *the_thread
+);
+
+/**
+ *  _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
+ */
+void _Scheduler_PerCore_SMP_Ready_queue_Enqueue_first(
+  Thread_Control    *the_thread
+);
+
+#ifndef __RTEMS_APPLICATION__
+#include <rtems/score/schedulerpercoresmp.inl>
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* RTEMS_SMP */
+
+/**@}*/
+
+#endif
+/* end of include file */

cpukit/score/include/rtems/score/smp.h

@@ -63 +63 @@
  */
 #define RTEMS_BSP_SMP_FIRST_TASK                0x08
 
+/**
+ *  This defines the bit which indicates the interprocessor interrupt
+ *  has been requested so that RTEMS will run the scheduler on this CPU
+ *  because the currently executing thread may need to be switched out.
+ */
+#define RTEMS_BSP_SMP_SCHEDULE_NECESSARY  0x10
+
 #ifndef ASM
 /**
  *  @brief Number of CPUs in SMP System

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

@@ +1 @@
+/** 
+ *  @file  rtems/score/schedulerpercoresmp.inl
+ *
+ *  This inline file contains all of the inlined routines associated with
+ *  the manipulation of the per-core SMP-aware scheduler structures.
+ */
+
+/*
+ *  Copyright (C) 2011 On-Line Applications Research Corporation (OAR).
+ *  Copyright (C) 2011 Kalray
+ *
+ *  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: schedulersimple.inl,v 1.1 2011/03/16 16:32:21 joel Exp $
+ */
+
+#ifndef _RTEMS_SCORE_SCHEDULERPERCORESMP_H
+# error "Never use <rtems/score/schedulerpercoresmp.inl> directly; include <rtems/score/schedulerpercoresmp.h> instead."
+#endif
+
+#ifndef RTEMS_SMP
+# error "SMP Scheduler include when SMP is not enabled"
+#endif
+
+#ifndef _RTEMS_SCORE_SCHEDULERPERCORESMP_INL
+#define _RTEMS_SCORE_SCHEDULERPERCORESMP_INL
+
+#include <rtems/score/thread.h>
+
+/**
+ *  @addtogroup ScoreScheduler
+ * @{
+ */
+
+/**
+ *  This routine puts @a the_thread on to the ready queue.
+ *
+ *  @param[in] the_ready_queue is a pointer to the ready queue head
+ *  @param[in] the_thread is the thread to be blocked
+ */
+RTEMS_INLINE_ROUTINE void _Scheduler_PerCore_SMP_Ready_queue_Requeue(
+  Scheduler_Control *the_ready_queue,
+  Thread_Control    *the_thread
+)
+{
+  /* extract */
+  _Chain_Extract_unprotected( &the_thread->Object.Node );
+
+  /* enqueue */
+  _Scheduler_PerCore_SMP_Ready_queue_Enqueue( the_thread );
+}
+
+/**@}*/
+
+#endif
+/* end of include file */

cpukit/score/preinstall.am

@@ -131 +131 @@
         $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/rtems/score/schedulersimple.h
 PREINSTALL_FILES += $(PROJECT_INCLUDE)/rtems/score/schedulersimple.h
 
+$(PROJECT_INCLUDE)/rtems/score/schedulerpercoresmp.h: include/rtems/score/schedulerpercoresmp.h $(PROJECT_INCLUDE)/rtems/score/$(dirstamp)
+        $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/rtems/score/schedulerpercoresmp.h
+PREINSTALL_FILES += $(PROJECT_INCLUDE)/rtems/score/schedulerpercoresmp.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
@@ -295 +299 @@
         $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/rtems/score/schedulersimple.inl
 PREINSTALL_FILES += $(PROJECT_INCLUDE)/rtems/score/schedulersimple.inl
 
+$(PROJECT_INCLUDE)/rtems/score/schedulerpercoresmp.inl: inline/rtems/score/schedulerpercoresmp.inl $(PROJECT_INCLUDE)/rtems/score/$(dirstamp)
+        $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/rtems/score/schedulerpercoresmp.inl
+PREINSTALL_FILES += $(PROJECT_INCLUDE)/rtems/score/schedulerpercoresmp.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

new file cpukit/score/src/schedulerpercoresmp.c

@@ +1 @@
+/*
+ *  Scheduler PerCoreSMP Handler / Initialize
+ *  Scheduler PerCoreSMP Handler / Allocate (Empty Routine)
+ *  Scheduler PerCoreSMP Handler / Update (Empty Routine)
+ *  Scheduler PerCoreSMP Handler / Free (Empty Routine)
+ *
+ *  COPYRIGHT (c) 2011.
+ *  On-Line Applications Research Corporation (OAR).
+ *  COPYRIGHT (c) 2011.
+ *  Kalray.
+ *
+ *  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
+
+#if defined(RTEMS_SMP)
+
+#include <rtems/system.h>
+#include <rtems/config.h>
+#include <rtems/score/chain.h>
+#include <rtems/score/scheduler.h>
+#include <rtems/score/schedulerpercoresmp.h>
+#include <rtems/score/thread.h>
+#include <rtems/score/smp.h>
+#include <rtems/score/wkspace.h>
+
+/**
+ * This routine does nothing, and is used as a stub for Schedule 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_PerCore_SMP_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 Schedule update
+ *
+ * The overhead of a function call will still be imposed.
+ */
+void _Scheduler_PerCore_SMP_Update( 
+  Thread_Control *the_thread
+)
+{
+}
+
+/**
+ * This routine does nothing, and is used as a stub for Schedule free
+ *
+ * The overhead of a function call will still be imposed.
+ */
+void _Scheduler_PerCore_SMP_Free( 
+  Thread_Control *the_thread
+)
+{
+}
+
+/**
+ * This routine initializes the simple scheduler.
+ *
+ * \note We assume nobody will get in our way here.
+ */
+void _Scheduler_PerCore_SMP_Initialize ( void )
+{
+  Scheduler_PerCore_SMP_Information *info;
+  int i;
+
+  /* 
+   * Initialize All Ready Queues
+   */
+  for (i = 0; i < _SMP_Processor_count; i++) {
+    /* allocate ready queue structures */
+    info = _Workspace_Allocate_or_fatal_error( sizeof(Scheduler_PerCore_SMP_Information) );
+    _Per_CPU_Information[i].scheduler_information = info;
+
+    /* initialize the lock */
+    _SMP_lock_spinlock_simple_Initialize( &(info->lock) );
+  
+    /* initialize ready queue structure */
+    _Chain_Initialize_empty( &(info->rq) );
+  }
+}
+
+#endif /* RTEMS_SMP */

new file cpukit/score/src/schedulerpercoresmpblock.c

@@ +1 @@
+/*
+ *  Scheduler PerCore SMP Handler / Block
+ *
+ *  COPYRIGHT (c) 2011.
+ *  On-Line Applications Research Corporation (OAR).
+ *  COPYRIGHT (c) 2011.
+ *  Kalray.
+ *
+ *  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
+
+#if defined(RTEMS_SMP)
+
+#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/smp.h>
+#include <rtems/score/schedulerpercoresmp.h>
+
+void _Scheduler_PerCore_SMP_Block(
+  Thread_Control   *the_thread
+)
+{
+  ISR_Level       level;
+  int core = the_thread->core;
+  Scheduler_PerCore_SMP_Information *info;
+
+  info = _Per_CPU_Information[core].scheduler_information;
+  
+  level = _SMP_lock_spinlock_simple_Obtain( &(info->lock) );
+  
+  _Scheduler_PerCore_SMP_Extract(the_thread);
+
+  /* We can run schedule directly only if the thread is 
+  on our CPU. Otherwise, we need to notify. */
+  if ( _Thread_Is_heir_SMP( the_thread, core ) ) {
+    if ( the_thread->core == bsp_smp_processor_id() ) {
+       _Scheduler_PerCore_SMP_Schedule_unprotected();
+    } else {
+       rtems_smp_send_message( core, RTEMS_BSP_SMP_SCHEDULE_NECESSARY );    
+    }
+  }
+
+  if ( _Thread_Is_executing_SMP( the_thread, core ) )
+  {
+    if ( core == bsp_smp_processor_id() ) {
+      _Per_CPU_Information[core].dispatch_necessary = true;
+    } else {
+      rtems_smp_send_message( core, RTEMS_BSP_SMP_CONTEXT_SWITCH_NECESSARY ); 
+    }
+  }
+  
+  _SMP_lock_spinlock_simple_Release( &(info->lock), level );
+}
+
+#endif

new file cpukit/score/src/schedulerpercoresmpenqueue.c

@@ +1 @@
+/*
+ *  Schedule PerCore SMP Handler / Enqueue
+ *
+ *  COPYRIGHT (c) 2011.
+ *  On-Line Applications Research Corporation (OAR).
+ *  COPYRIGHT (c) 2011.
+ *  Kalray.
+ *
+ *  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
+
+#if defined(RTEMS_SMP)
+
+#include <rtems/system.h>
+#include <rtems/score/chain.h>
+#include <rtems/score/isr.h>
+#include <rtems/score/thread.h>
+#include <rtems/score/schedulerpercoresmp.h>
+
+void _Scheduler_PerCore_SMP_Enqueue(
+  Thread_Control            *the_thread
+)
+{
+  Scheduler_PerCore_SMP_Information *info;
+  int core;
+  ISR_Level level;
+
+  core = the_thread->core;
+  info =  _Per_CPU_Information[core].scheduler_information;
+  
+  level = _SMP_lock_spinlock_simple_Obtain( &(info->lock) );
+  _Scheduler_PerCore_SMP_Ready_queue_Enqueue( the_thread );
+  _SMP_lock_spinlock_simple_Release( &(info->lock), level );
+}
+
+#endif

new file cpukit/score/src/schedulerpercoresmpenqueuefirst.c

@@ +1 @@
+/*
+ *  Schedule PerCore SMP Handler / Enqueue First
+ *
+ *  COPYRIGHT (c) 2011.
+ *  On-Line Applications Research Corporation (OAR).
+ *  COPYRIGHT (c) 2011.
+ *  Kalray.
+ *
+ *  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
+
+#if defined(RTEMS_SMP)
+
+#include <rtems/system.h>
+#include <rtems/score/chain.h>
+#include <rtems/score/thread.h>
+#include <rtems/score/schedulerpercoresmp.h>
+
+void _Scheduler_PerCore_SMP_Enqueue_first(
+  Thread_Control            *the_thread
+)
+{
+  Scheduler_PerCore_SMP_Information *info;
+  int core;
+  ISR_Level level;
+
+  core = the_thread->core;
+  info =  _Per_CPU_Information[core].scheduler_information;
+  
+  level = _SMP_lock_spinlock_simple_Obtain( &(info->lock) );
+  _Scheduler_PerCore_SMP_Ready_queue_Enqueue_first( the_thread );
+  _SMP_lock_spinlock_simple_Release( &(info->lock), level );
+}
+
+#endif

new file cpukit/score/src/schedulerpercoresmpextract.c

@@ +1 @@
+/*
+ *  Schedule PerCore SMP Handler / Extract 
+ *
+ *  COPYRIGHT (c) 2011.
+ *  On-Line Applications Research Corporation (OAR).
+ *  COPYRIGHT (c) 2011.
+ *  Kalray.
+ *
+ *  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
+
+#if defined(RTEMS_SMP)
+
+#include <rtems/system.h>
+#include <rtems/score/chain.h>
+#include <rtems/score/interr.h>
+#include <rtems/score/thread.h>
+#include <rtems/score/schedulerpercoresmp.h>
+
+//#define LOCAL_DEBUG
+
+#ifdef LOCAL_DEBUG
+#define D(format,...) printk( format, __VA_ARGS__)
+#else
+#define D(format,...) 
+#endif
+
+#ifdef LOCAL_DEBUG
+static inline _Scheduler_PerCore_SMP_Show_chain(Chain_Control *ready, int core)
+{
+  Chain_Node *the_node = _Chain_First( ready );
+  D( "SCHED core %d showing list %p\n -- \n", core, ready );
+  for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
+    D( "SCHED element %p\n", the_node );
+  }
+  D( "--\nSCHED list end %d -- \n", core );
+}
+#else
+static inline _Scheduler_PerCore_SMP_Show_chain(Chain_Control *ready, int core)
+{
+}
+#endif
+
+/* This function is called internally. We assume that it is always
+   in the critical section. */
+
+void _Scheduler_PerCore_SMP_Extract(
+  Thread_Control    *the_thread
+)
+{
+  Scheduler_PerCore_SMP_Information *info;
+  int core;
+  ISR_Level level;
+  Chain_Control *ready;
+
+  core = the_thread->core;
+  info =  _Per_CPU_Information[core].scheduler_information;
+  ready    = &(info->rq);
+  
+  D( "SCHED core %d extracting %p\n", core, the_thread );
+  
+  _Chain_Extract_unprotected( &the_thread->Object.Node );
+  _Scheduler_PerCore_SMP_Show_chain(ready, core);
+}
+
+#endif

new file cpukit/score/src/schedulerpercoresmpreadyqueueenqueue.c

@@ +1 @@
+/*
+ *  Schedule PerCoreSMP Handler / Ready Queue Enqueue
+ *
+ *  COPYRIGHT (c) 2011.
+ *  On-Line Applications Research Corporation (OAR).
+ *  COPYRIGHT (c) 2011.
+ *  Kalray.
+ *
+ *  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
+
+#if defined(RTEMS_SMP)
+
+#include <rtems/system.h>
+#include <rtems/score/chain.h>
+#include <rtems/score/interr.h>
+#include <rtems/score/isr.h>
+#include <rtems/score/thread.h>
+#include <rtems/score/schedulerpercoresmp.h>
+
+//#define LOCAL_DEBUG
+
+#ifdef LOCAL_DEBUG
+#define D(format,...) printk( format, __VA_ARGS__)
+#else
+#define D(format,...) 
+#endif
+
+#ifdef LOCAL_DEBUG
+static inline _Scheduler_PerCore_SMP_Show_chain(Chain_Control *ready, int core)
+{
+  Chain_Node *the_node = _Chain_First( ready );
+  D( "SCHED core %d showing list %p\n -- \n", core, ready );
+  for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
+    D( "SCHED element %p\n", the_node );
+  }
+  D( "--\nSCHED list end %d -- \n", core );
+}
+#else
+static inline _Scheduler_PerCore_SMP_Show_chain(Chain_Control *ready, int core)
+{
+}
+#endif
+
+void _Scheduler_PerCore_SMP_Ready_queue_Enqueue(
+  Thread_Control    *the_thread
+)
+{
+  Chain_Control    *ready;
+  Chain_Node       *the_node;
+  Thread_Control   *current;
+  Scheduler_PerCore_SMP_Information *info;
+  int core;
+
+  core = the_thread->core;
+  
+  info =  _Per_CPU_Information[core].scheduler_information;
+  ready    = &(info->rq);
+  the_node = _Chain_First( ready );
+  current  = (Thread_Control *)the_node;
+
+  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;
+    }
+  }
+
+  if (_Chain_Is_tail( ready, the_node))
+  {
+    /* Insert just after the head. Possibly we're inserting IDLE now */
+    D( "SCHED core %d inserting head %p\n", core, the_thread );
+    _Chain_Insert_unprotected( _Chain_Head(ready), &the_thread->Object.Node );
+  }
+  else
+  {
+    /* enqueue */
+    D( "SCHED core %d inserting middle %p\n", core, the_thread );
+    _Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
+  }
+  _Scheduler_PerCore_SMP_Show_chain(ready, core);
+}
+
+#endif

new file cpukit/score/src/schedulerpercoresmpreadyqueueenqueuefirst.c

@@ +1 @@
+/*
+ *  Schedule PerCoreSMP Handler / Ready Queue Enqueue First
+ *
+ *  COPYRIGHT (c) 2011.
+ *  On-Line Applications Research Corporation (OAR).
+ *  COPYRIGHT (c) 2011.
+ *  Kalray.
+ *
+ *  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
+
+#if defined(RTEMS_SMP)
+
+#include <rtems/system.h>
+#include <rtems/score/chain.h>
+#include <rtems/score/interr.h>
+#include <rtems/score/thread.h>
+#include <rtems/score/schedulerpercoresmp.h>
+
+void _Scheduler_PerCore_SMP_Ready_queue_Enqueue_first(
+  Thread_Control    *the_thread
+)
+{
+  Chain_Control    *ready;
+  Chain_Node       *the_node;
+  Thread_Control   *current;
+  Scheduler_PerCore_SMP_Information *info;
+  int core;
+  
+  core = the_thread->core;
+  
+  info =  _Per_CPU_Information[core].scheduler_information;
+  ready    = &(info->rq);
+  the_node = _Chain_First( ready );
+  current  = (Thread_Control *)the_node;
+
+  /*
+   * Do NOT need to check for end of chain because there is always
+   * at least one task on the ready chain -- the IDLE task.  It can
+   * never block, should never attempt to obtain a semaphore or mutex,
+   * and thus will always be there.
+   */
+  for ( the_node = _Chain_First(ready) ; ; 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 );
+}
+
+#endif

new file cpukit/score/src/schedulerpercoresmpschedule.c

@@ +1 @@
+/*
+ *  Scheduler PerCore SMP Handler / Schedule
+ *
+ *  COPYRIGHT (c) 2011.
+ *  On-Line Applications Research Corporation (OAR).
+ *  COPYRIGHT (c) 2011.
+ *  Kalray.
+ *
+ *  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
+
+#if defined(RTEMS_SMP)
+
+#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/schedulerpercoresmp.h>
+
+void _Scheduler_PerCore_SMP_Schedule_unprotected(void)
+{
+  Scheduler_PerCore_SMP_Information *info;
+  info = _Per_CPU_Information[bsp_smp_processor_id()].scheduler_information;
+  _Per_CPU_Information[bsp_smp_processor_id()].heir = (Thread_Control *) _Chain_First( &(info->rq) );
+}
+
+void _Scheduler_PerCore_SMP_Schedule(void)
+{
+  ISR_Level level;
+  Scheduler_PerCore_SMP_Information *info;
+  info = _Per_CPU_Information[bsp_smp_processor_id()].scheduler_information;
+  
+  level = _SMP_lock_spinlock_simple_Obtain( &(info->lock) );
+  _Scheduler_PerCore_SMP_Schedule_unprotected();
+  _SMP_lock_spinlock_simple_Release( &(info->lock), level );
+}
+
+#endif

new file cpukit/score/src/schedulerpercoresmpunblock.c

@@ +1 @@
+/*
+ *  Scheduler PerCore SMP Handler / Unblock
+ *
+ *  COPYRIGHT (c) 2011.
+ *  On-Line Applications Research Corporation (OAR).
+ *  COPYRIGHT (c) 2011.
+ *  Kalray.
+ *
+ *  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
+
+#if defined(RTEMS_SMP)
+
+#include <rtems/system.h>
+#include <rtems/score/interr.h>
+#include <rtems/score/isr.h>
+#include <rtems/score/schedulerpercoresmp.h>
+#include <rtems/score/thread.h>
+#include <rtems/score/smp.h>
+
+void _Scheduler_PerCore_SMP_Unblock(
+  Thread_Control    *the_thread
+)
+{
+  int core;
+  ISR_Level       level;
+  Scheduler_PerCore_SMP_Information *info;
+
+  core = the_thread->core;
+  info = _Per_CPU_Information[core].scheduler_information;
+  
+  level = _SMP_lock_spinlock_simple_Obtain( &(info->lock) );
+  
+  _Scheduler_PerCore_SMP_Ready_queue_Enqueue(the_thread);
+
+  /*
+   *  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 <  _Per_CPU_Information[core].heir->current_priority ) {
+    _Per_CPU_Information[core].heir = the_thread;
+    if (  _Per_CPU_Information[core].executing->is_preemptible ||
+        the_thread->current_priority == 0 ) {
+       if (core == bsp_smp_processor_id())
+         _Per_CPU_Information[core].dispatch_necessary = true;
+       else
+         rtems_smp_send_message( core, RTEMS_BSP_SMP_CONTEXT_SWITCH_NECESSARY ); 
+    }
+  }
+  _SMP_lock_spinlock_simple_Release( &(info->lock), level );
+}
+
+#endif

new file cpukit/score/src/schedulerpercoresmpyield.c

@@ +1 @@
+/*
+ *  Scheduler PerCore SMP Handler / Yield
+ *
+ *  COPYRIGHT (c) 2011.
+ *  On-Line Applications Research Corporation (OAR).
+ *  COPYRIGHT (c) 2011.
+ *  Kalray
+ *
+ *  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: schedulersimpleyield.c,v 1.1 2011/03/16 16:32:22 joel Exp $
+ */
+
+#if HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#if defined(RTEMS_SMP)
+
+#include <rtems/system.h>
+#include <rtems/score/isr.h>
+#include <rtems/score/scheduler.h>
+#include <rtems/score/thread.h>
+#include <rtems/score/schedulerpercoresmp.h>
+
+void _Scheduler_PerCore_SMP_Yield( void )
+{
+  ISR_Level       level;
+  Thread_Control *executing;
+  Scheduler_PerCore_SMP_Information *info;
+
+  info = _Per_CPU_Information[bsp_smp_processor_id()].scheduler_information;
+  level = _SMP_lock_spinlock_simple_Obtain( &(info->lock) );
+  
+  executing = _Per_CPU_Information[bsp_smp_processor_id()].executing;
+  
+  _Scheduler_PerCore_SMP_Ready_queue_Requeue(&_Scheduler, executing);
+
+  _Scheduler_PerCore_SMP_Schedule_unprotected();
+  
+  /* This is only on local core, so we do not send messages */
+  if ( !_Thread_Is_heir( executing ) )
+    _Per_CPU_Information[bsp_smp_processor_id()].dispatch_necessary = true;
+
+  _SMP_lock_spinlock_simple_Release ( &(info->lock), level );
+}
+
+#endif