Changeset ac532f3 in rtems

Timestamp:

07/04/14 11:40:10 (9 years ago)

Author:

Sebastian Huber <sebastian.huber@…>

Branches:

4.11, 5, master

Children:

8568341

Parents:

08d9760

git-author:

Sebastian Huber <sebastian.huber@…> (07/04/14 11:40:10)

git-committer:

Sebastian Huber <sebastian.huber@…> (07/08/14 14:30:48)

Message:

score: Add _Scheduler_Help()

Manage the help state of threads with respect to scheduling decisions.

Location:

cpukit/score/include/rtems/score

Files:

• mrspimpl.h (modified) (5 diffs)
• scheduler.h (modified) (2 diffs)
• schedulerimpl.h (modified) (3 diffs)
• schedulersmpimpl.h (modified) (1 diff)

cpukit/score/include/rtems/score/mrspimpl.h

@@ -103 +103 @@
   mrsp->initial_priority_of_owner = initial_priority;
   _MRSP_Elevate_priority( mrsp, new_owner, ceiling_priority );
+  _Scheduler_Thread_change_help_state( new_owner, SCHEDULER_HELP_ACTIVE_OWNER );
 }
 
@@ -186 +187 @@
   bool previous_life_protection;
   unsigned int state;
+  Scheduler_Help_state previous_help_state;
 
   _MRSP_Elevate_priority( mrsp, executing, ceiling_priority );
@@ -194 +196 @@
   _Resource_Add_rival( &mrsp->Resource, &executing->Resource_node );
   _Resource_Node_set_dependency( &executing->Resource_node, &mrsp->Resource );
+  previous_help_state =
+    _Scheduler_Thread_change_help_state( executing, SCHEDULER_HELP_ACTIVE_RIVAL );
   _MRSP_Set_root(
     &executing->Resource_node,
@@ -235 +239 @@
     status = MRSP_SUCCESSFUL;
   } else {
-    Resource_Node *executing_node = &executing->Resource_node;
-
-    _Resource_Node_extract( executing_node );
-    _Resource_Node_set_dependency( executing_node, NULL );
-    _MRSP_Set_root( executing_node, executing_node );
+    _Resource_Node_extract( &executing->Resource_node );
+    _Resource_Node_set_dependency( &executing->Resource_node, NULL );
+    _Scheduler_Thread_change_help_state( executing, previous_help_state );
+    _MRSP_Set_root( &executing->Resource_node, &executing->Resource_node );
     _MRSP_Restore_priority( mrsp, executing, initial_priority );
 
@@ -325 +328 @@
   } else {
     MRSP_Rival *rival = (MRSP_Rival *) _Chain_First( &mrsp->Rivals );
-    Resource_Node *new_owner = &rival->thread->Resource_node;
-
-    _Resource_Node_extract( new_owner );
-    _Resource_Node_set_dependency( new_owner, NULL );
-    _Resource_Node_add_resource( new_owner, &mrsp->Resource );
-    _Resource_Set_owner( &mrsp->Resource, new_owner );
-    _MRSP_Set_root( new_owner, new_owner );
+    Thread_Control *new_owner = rival->thread;
+
+    _Resource_Node_extract( &new_owner->Resource_node );
+    _Resource_Node_set_dependency( &new_owner->Resource_node, NULL );
+    _Resource_Node_add_resource( &new_owner->Resource_node, &mrsp->Resource );
+    _Resource_Set_owner( &mrsp->Resource, &new_owner->Resource_node );
+    _Scheduler_Thread_change_help_state( new_owner, SCHEDULER_HELP_ACTIVE_OWNER );
+    _MRSP_Set_root( &new_owner->Resource_node, &new_owner->Resource_node );
     _MRSP_Add_state( rival, MRSP_RIVAL_STATE_NEW_OWNER );
+  }
+
+  if ( !_Resource_Node_owns_resources( &executing->Resource_node ) ) {
+    _Scheduler_Thread_change_help_state( executing, SCHEDULER_HELP_YOURSELF );
   }
 

cpukit/score/include/rtems/score/scheduler.h

@@ -162 +162 @@
 };
 
+#if defined(RTEMS_SMP)
+/**
+ * @brief State to indicate potential help for other threads.
+ *
+ * @dot
+ * digraph state {
+ *   y [label="HELP YOURSELF"];
+ *   ao [label="HELP ACTIVE OWNER"];
+ *   ar [label="HELP ACTIVE RIVAL"];
+ *
+ *   y -> ao [label="obtain"];
+ *   y -> ar [label="wait for obtain"];
+ *   ao -> y [label="last release"];
+ *   ao -> r [label="wait for obtain"];
+ *   ar -> r [label="timeout"];
+ *   ar -> ao [label="timeout"];
+ * }
+ * @enddot
+ */
+typedef enum {
+  /**
+   * @brief This scheduler node is solely used by the owner thread.
+   *
+   * This thread owns no resources using a helping protocol and thus does not
+   * take part in the scheduler helping protocol.  No help will be provided for
+   * other thread.
+   */
+  SCHEDULER_HELP_YOURSELF,
+
+  /**
+   * @brief This scheduler node is owned by a thread actively owning a resource.
+   *
+   * This scheduler node can be used to help out threads.
+   *
+   * In case this scheduler node changes its state from ready to scheduled and
+   * the thread executes using another node, then an idle thread will be
+   * provided as a user of this node to temporarily execute on behalf of the
+   * owner thread.  Thus lower priority threads are denied access to the
+   * processors of this scheduler instance.
+   *
+   * In case a thread actively owning a resource performs a blocking operation,
+   * then an idle thread will be used also in case this node is in the
+   * scheduled state.
+   */
+  SCHEDULER_HELP_ACTIVE_OWNER,
+
+  /**
+   * @brief This scheduler node is owned by a thread actively obtaining a
+   * resource currently owned by another thread.
+   *
+   * This scheduler node can be used to help out threads.
+   *
+   * The thread owning this node is ready and will give away its processor in
+   * case the thread owning the resource asks for help.
+   */
+  SCHEDULER_HELP_ACTIVE_RIVAL,
+
+  /**
+   * @brief This scheduler node is owned by a thread obtaining a
+   * resource currently owned by another thread.
+   *
+   * This scheduler node can be used to help out threads.
+   *
+   * The thread owning this node is blocked.
+   */
+  SCHEDULER_HELP_PASSIVE
+} Scheduler_Help_state;
+#endif
+
 /**
  * @brief Scheduler node for per-thread data.
@@ -180 +249 @@
 
   /**
+   * @brief The thread using this node.
+   */
+  Thread_Control *user;
+
+  /**
+   * @brief The help state of this node.
+   */
+  Scheduler_Help_state help_state;
+
+  /**
    * @brief The thread owning this node.
    */
   Thread_Control *owner;
+
+  /**
+   * @brief The idle thread claimed by this node in case the help state is
+   * SCHEDULER_HELP_ACTIVE_OWNER.
+   *
+   * Active owners will lend their own node to an idle thread in case they
+   * execute currently using another node or in case they perform a blocking
+   * operation.  This is necessary to ensure the priority ceiling protocols
+   * work across scheduler boundaries.
+   */
+  Thread_Control *idle;
+
+  /**
+   * @brief The thread accepting help by this node in case the help state is
+   * not SCHEDULER_HELP_YOURSELF.
+   */
+  Thread_Control *accepts_help;
 #endif
 };

cpukit/score/include/rtems/score/schedulerimpl.h

@@ -77 +77 @@
   return _Scheduler_Get_by_CPU_index( cpu_index );
 }
+
+#if defined(RTEMS_SMP)
+RTEMS_INLINE_ROUTINE Thread_Control *_Scheduler_Node_get_user(
+  const Scheduler_Node *node
+)
+{
+  return node->user;
+}
+#endif
 
 /**
@@ -659 +668 @@
 {
 #if defined(RTEMS_SMP)
+  node->user = the_thread;
+  node->help_state = SCHEDULER_HELP_YOURSELF;
   node->owner = the_thread;
+  node->idle = NULL;
+  node->accepts_help = the_thread;
 #else
   (void) node;
@@ -673 +686 @@
   return node->owner;
 }
+
+RTEMS_INLINE_ROUTINE Thread_Control *_Scheduler_Node_get_idle(
+  const Scheduler_Node *node
+)
+{
+  return node->idle;
+}
+
+/**
+ * @brief Changes the scheduler help state of a thread.
+ *
+ * @param[in] the_thread The thread.
+ * @param[in] new_help_state The new help state.
+ *
+ * @return The previous help state.
+ */
+RTEMS_INLINE_ROUTINE Scheduler_Help_state _Scheduler_Thread_change_help_state(
+  Thread_Control       *the_thread,
+  Scheduler_Help_state  new_help_state
+)
+{
+  Scheduler_Node *node = _Scheduler_Thread_get_node( the_thread );
+  Scheduler_Help_state previous_help_state = node->help_state;
+
+  node->help_state = new_help_state;
+
+  return previous_help_state;
+}
 #endif
 

cpukit/score/include/rtems/score/schedulersmpimpl.h

@@ -456 +456 @@
 )
 {
-  Thread_Control *scheduled_thread = _Scheduler_Node_get_owner( scheduled );
-  Thread_Control *victim_thread = _Scheduler_Node_get_owner( victim );
+  Thread_Control *scheduled_thread = _Scheduler_Node_get_user( scheduled );
+  Thread_Control *victim_thread = _Scheduler_Node_get_user( victim );
 
   _Scheduler_SMP_Node_change_state(