time_bench_sample: measure spin_lock_irqsave + spin_unlock_irqrestore

Add some measurements to determine the cost of the spinlock
variant that disable/enable interrupts, with save/restore flags.

This should help us determine:
 1. How expensive is this compared to the basic spinlock,
 2. is a "manual" save/restore before spinlock as expensive
    or is there some advantage of the combined func call

Measured on my laptop CPU i7-2620M CPU @ 2.70GHz:
(kernel 3.17.8-200.fc20.x86_64)

 * 12.775 ns - "clean" spin_lock_unlock
 * 21.099 ns - irqsave variant spinlock
 * 22.808 ns - "manual" irqsave before spin_lock
 * 14.618 ns - "manual" local_irq_disable + spin_lock

The clean spin_lock_unlock is 8.324 ns faster than irqsave variant.
The irqsave variant is actually faster than expected, as the measurement
of an isolated local_irq_save_restore were 13.256 ns.

The difference to the "manual" irqsave is only 1.709 ns, which is approx
the cost of an extra function call.

If one can use the non-flags-save version of local_irq_disable, then one
can save 6.481 ns (on this specific CPU and kernel config).

Signed-off-by: Jesper Dangaard Brouer <brouer@redhat.com>

Author: netoptimizer

kernel/lib/time_bench_sample.c

@@ -49,6 +49,72 @@ static int time_lock_unlock(
 	return loops_cnt;
 }
 
+static int time_lock_unlock_irqsave(
+	struct time_bench_record *rec, void *data)
+{
+	int i;
+	unsigned long flags;
+	uint64_t loops_cnt = 0;
+
+	time_bench_start(rec);
+	/** Loop to measure **/
+	for (i = 0; i < rec->loops; i++) {
+		spin_lock_irqsave(&my_lock, flags);
+		loops_cnt++;
+		barrier();
+		spin_unlock_irqrestore(&my_lock, flags);
+	}
+	time_bench_stop(rec, loops_cnt);
+	return loops_cnt;
+}
+
+/* Purpose of this func, is to determine of the combined
+ * spin_lock_irqsave() call is more efficient than "manually" irqsave
+ * before calling lock.
+ */
+static int time_irqsave_before_lock(
+	struct time_bench_record *rec, void *data)
+{
+	int i;
+	unsigned long flags;
+	uint64_t loops_cnt = 0;
+
+	time_bench_start(rec);
+	/** Loop to measure **/
+	for (i = 0; i < rec->loops; i++) {
+		local_irq_save(flags);
+		spin_lock(&my_lock);
+		loops_cnt++;
+		barrier();
+		spin_unlock(&my_lock);
+		local_irq_restore(flags);
+	}
+	time_bench_stop(rec, loops_cnt);
+	return loops_cnt;
+}
+
+/* How much is there to save when using non-flags save variant of
+ * disabling interrupts */
+static int time_simple_irq_disable_before_lock(
+	struct time_bench_record *rec, void *data)
+{
+	int i;
+	uint64_t loops_cnt = 0;
+
+	time_bench_start(rec);
+	/** Loop to measure **/
+	for (i = 0; i < rec->loops; i++) {
+		local_irq_disable();
+		spin_lock(&my_lock);
+		loops_cnt++;
+		barrier();
+		spin_unlock(&my_lock);
+		local_irq_enable();
+	}
+	time_bench_stop(rec, loops_cnt);
+	return loops_cnt;
+}
+
 static int time_local_bh(
 	struct time_bench_record *rec, void *data)
 {
@@ -203,6 +269,15 @@ int run_timing_tests(void)
 	time_bench_loop(loops, 0, "spin_lock_unlock",
 			NULL, time_lock_unlock);
 
+	time_bench_loop(loops/2, 0, "spin_lock_unlock_irqsave",
+			NULL, time_lock_unlock_irqsave);
+
+	time_bench_loop(loops/2, 0, "irqsave_before_lock",
+			NULL, time_irqsave_before_lock);
+
+	time_bench_loop(loops/2, 0, "simple_irq_disable_before_lock",
+			NULL, time_simple_irq_disable_before_lock);
+
 	/* Cost for local_bh_{disable,enable}
 	 *  7.387 ns with CONFIG_PREEMPT=n PREEMPT_COUNT=n
 	 *  7.459 ns with CONFIG_PREEMPT=n PREEMPT_COUNT=y