rcu: demote SRCU_SYNCHRONIZE_DELAY from kernel-parameter status
Paul E. McKenney [Fri, 7 Jan 2011 10:33:47 +0000 (02:33 -0800)]
Because the adaptive synchronize_srcu_expedited() approach has
worked very well in testing, remove the kernel parameter and
replace it by a C-preprocessor macro.  If someone finds problems
with this approach, a more complex and aggressively adaptive
approach might be required.

Longer term, SRCU will be merged with the other RCU implementations,
at which point synchronize_srcu_expedited() will be event driven,
just as synchronize_sched_expedited() currently is.  At that point,
there will be no need for this adaptive approach.

Reported-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>

init/Kconfig
kernel/srcu.c

index 526ec1c..e11bc79 100644 (file)
@@ -497,21 +497,6 @@ config RCU_BOOST_DELAY
 
          Accept the default if unsure.
 
-config SRCU_SYNCHRONIZE_DELAY
-       int "Microseconds to delay before waiting for readers"
-       range 0 20
-       default 10
-       help
-         This option controls how long SRCU delays before entering its
-         loop waiting on SRCU readers.  The purpose of this loop is
-         to avoid the unconditional context-switch penalty that would
-         otherwise be incurred if there was an active SRCU reader,
-         in a manner similar to adaptive locking schemes.  This should
-         be set to be a bit longer than the common-case SRCU read-side
-         critical-section overhead.
-
-         Accept the default if unsure.
-
 endmenu # "RCU Subsystem"
 
 config IKCONFIG
index 98d8c1e..73ce23f 100644 (file)
@@ -156,6 +156,16 @@ void __srcu_read_unlock(struct srcu_struct *sp, int idx)
 EXPORT_SYMBOL_GPL(__srcu_read_unlock);
 
 /*
+ * We use an adaptive strategy for synchronize_srcu() and especially for
+ * synchronize_srcu_expedited().  We spin for a fixed time period
+ * (defined below) to allow SRCU readers to exit their read-side critical
+ * sections.  If there are still some readers after 10 microseconds,
+ * we repeatedly block for 1-millisecond time periods.  This approach
+ * has done well in testing, so there is no need for a config parameter.
+ */
+#define SYNCHRONIZE_SRCU_READER_DELAY 10
+
+/*
  * Helper function for synchronize_srcu() and synchronize_srcu_expedited().
  */
 static void __synchronize_srcu(struct srcu_struct *sp, void (*sync_func)(void))
@@ -207,11 +217,12 @@ static void __synchronize_srcu(struct srcu_struct *sp, void (*sync_func)(void))
         * will have finished executing.  We initially give readers
         * an arbitrarily chosen 10 microseconds to get out of their
         * SRCU read-side critical sections, then loop waiting 1/HZ
-        * seconds per iteration.
+        * seconds per iteration.  The 10-microsecond value has done
+        * very well in testing.
         */
 
        if (srcu_readers_active_idx(sp, idx))
-               udelay(CONFIG_SRCU_SYNCHRONIZE_DELAY);
+               udelay(SYNCHRONIZE_SRCU_READER_DELAY);
        while (srcu_readers_active_idx(sp, idx))
                schedule_timeout_interruptible(1);