Changeset 8d6e6eeb in rtems

Timestamp:

02/17/15 09:00:43 (9 years ago)

Author:

Sebastian Huber <sebastian.huber@…>

Branches:

4.11, 5, master

Children:

7fcb71a

Parents:

c34f94f7

git-author:

Sebastian Huber <sebastian.huber@…> (02/17/15 09:00:43)

git-committer:

Sebastian Huber <sebastian.huber@…> (02/17/15 12:42:53)

Message:

score: Fix FP context restore via _Thread_Handler

After a context switch we end up in the second part of
_Thread_Dispatch() or in _Thread_Handler() in case of new threads. Use
the same function _Thread_Restore_fp() to restore the floating-point
context. It makes no sense to do this in _Thread_Start_multitasking().
This fixes also a race condition in SMP configurations.

Update #2268.

Location:

cpukit/score

Files:

• include/rtems/score/threadimpl.h (modified) (1 diff)
• src/threaddispatch.c (modified) (1 diff)
• src/threadhandler.c (modified) (1 diff)
• src/threadstartmultitasking.c (modified) (1 diff)

cpukit/score/include/rtems/score/threadimpl.h

@@ -588 +588 @@
 #endif
 
+/*
+ *  If the CPU has hardware floating point, then we must address saving
+ *  and restoring it as part of the context switch.
+ *
+ *  The second conditional compilation section selects the algorithm used
+ *  to context switch between floating point tasks.  The deferred algorithm
+ *  can be significantly better in a system with few floating point tasks
+ *  because it reduces the total number of save and restore FP context
+ *  operations.  However, this algorithm can not be used on all CPUs due
+ *  to unpredictable use of FP registers by some compilers for integer
+ *  operations.
+ */
+
+RTEMS_INLINE_ROUTINE void _Thread_Save_fp( Thread_Control *executing )
+{
+#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
+#if ( CPU_USE_DEFERRED_FP_SWITCH != TRUE )
+  if ( executing->fp_context != NULL )
+    _Context_Save_fp( &executing->fp_context );
+#endif
+#endif
+}
+
+RTEMS_INLINE_ROUTINE void _Thread_Restore_fp( Thread_Control *executing )
+{
+#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
+#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
+  if ( (executing->fp_context != NULL) &&
+       !_Thread_Is_allocated_fp( executing ) ) {
+    if ( _Thread_Allocated_fp != NULL )
+      _Context_Save_fp( &_Thread_Allocated_fp->fp_context );
+    _Context_Restore_fp( &executing->fp_context );
+    _Thread_Allocated_fp = executing;
+  }
+#else
+  if ( executing->fp_context != NULL )
+    _Context_Restore_fp( &executing->fp_context );
+#endif
+#endif
+}
+
 /**
  * This routine is invoked when the currently loaded floating

cpukit/score/src/threaddispatch.c

@@ -143 +143 @@
 
     _User_extensions_Thread_switch( executing, heir );
-
-    /*
-     *  If the CPU has hardware floating point, then we must address saving
-     *  and restoring it as part of the context switch.
-     *
-     *  The second conditional compilation section selects the algorithm used
-     *  to context switch between floating point tasks.  The deferred algorithm
-     *  can be significantly better in a system with few floating point tasks
-     *  because it reduces the total number of save and restore FP context
-     *  operations.  However, this algorithm can not be used on all CPUs due
-     *  to unpredictable use of FP registers by some compilers for integer
-     *  operations.
-     */
-
-#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
-#if ( CPU_USE_DEFERRED_FP_SWITCH != TRUE )
-    if ( executing->fp_context != NULL )
-      _Context_Save_fp( &executing->fp_context );
-#endif
-#endif
-
+    _Thread_Save_fp( executing );
     _Context_Switch( &executing->Registers, &heir->Registers );
-
-#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
-#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
-    if ( (executing->fp_context != NULL) &&
-         !_Thread_Is_allocated_fp( executing ) ) {
-      if ( _Thread_Allocated_fp != NULL )
-        _Context_Save_fp( &_Thread_Allocated_fp->fp_context );
-      _Context_Restore_fp( &executing->fp_context );
-      _Thread_Allocated_fp = executing;
-    }
-#else
-    if ( executing->fp_context != NULL )
-      _Context_Restore_fp( &executing->fp_context );
-#endif
-#endif
+    _Thread_Restore_fp( executing );
 
     /*

cpukit/score/src/threadhandler.c

@@ -52 +52 @@
    * code path for performing the FP context switch is not hit.
    */
-  #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
-    #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
-      if ( (executing->fp_context != NULL) &&
-            !_Thread_Is_allocated_fp( executing ) ) {
-        if ( _Thread_Allocated_fp != NULL )
-          _Context_Save_fp( &_Thread_Allocated_fp->fp_context );
-        _Thread_Allocated_fp = executing;
-      }
-    #endif
-  #endif
+  _Thread_Restore_fp( executing );
 
   /*

cpukit/score/src/threadstartmultitasking.c

@@ -38 +38 @@
   heir = _Thread_Get_heir_and_make_it_executing( cpu_self );
 
-   /*
-    * Get the init task(s) running.
-    *
-    * Note: Thread_Dispatch() is normally used to dispatch threads.  As
-    *       part of its work, Thread_Dispatch() restores floating point
-    *       state for the heir task.
-    *
-    *       This code avoids Thread_Dispatch(), and so we have to restore
-    *       (actually initialize) the floating point state "by hand".
-    *
-    *       Ignore the CPU_USE_DEFERRED_FP_SWITCH because we must always
-    *       switch in the first thread if it is FP.
-    */
-#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
-   /*
-    *  don't need to worry about saving BSP's floating point state
-    */
-
-   if ( heir->fp_context != NULL )
-     _Context_Restore_fp( &heir->fp_context );
-#endif
-
   _Profiling_Thread_dispatch_disable( cpu_self, 0 );