Try to smoothen benchmark results, let them be more thruthful

benchmarks/finagle/src/main/scala/com/twitter/finagle/redis/FinaglePingBench.scala

@@ -48,20 +48,31 @@ class FinaglePingBench {
   }
 
   @Benchmark
-  def async(): Future[String] =
-    client.doRequest(FinaglePingBench.Ping) {
-      case BulkReply(message) ⇒ Future.value(message.toString(Utf8))
-    }
+  @OperationsPerInvocation(100000)
+  def async_100000(): String = {
+    (1 until 100000).foreach(_ ⇒ FinaglePingBench.ping(client))
+    Await.result(FinaglePingBench.ping(client))
+  }
+
+  @Benchmark
+  @OperationsPerInvocation(10000)
+  def async_10000(): String = {
+    (1 until 10000).foreach(_ ⇒ FinaglePingBench.ping(client))
+    Await.result(FinaglePingBench.ping(client))
+  }
 
   @Benchmark
   def sync(): String =
-    Await.result(client.doRequest(FinaglePingBench.Ping) {
-      case StatusReply(message) ⇒ Future.value(message)
-    })
+    Await.result(FinaglePingBench.ping(client))
 }
 object FinaglePingBench {
   object Ping extends Command {
     val command = "PING"
     val toChannelBuffer = RedisCodec.toUnifiedFormat(Seq(StringToChannelBuffer("PING")))
   }
+
+  def ping(client: Client): Future[String] = client.doRequest(Ping) {
+    case StatusReply(message) ⇒ Future.value(message)
+    case BulkReply(message)   ⇒ Future.value(message.toString(Utf8))
+  }
 }

benchmarks/scala-redis-nb/src/main/scala/rx/redis/ScalaRedisNbPingBench.scala

@@ -57,10 +57,20 @@ class ScalaRedisNbPingBench {
   }
 
   @Benchmark
-  def async(): Future[Ping.Ret] =
-    client.ping()
+  @OperationsPerInvocation(100000)
+  def async_100000(): Boolean = {
+    (1 until 100000).foreach(_ ⇒ client.ping())
+    Await.result(client.ping(), Duration.Inf)
+  }
+
+  @Benchmark
+  @OperationsPerInvocation(10000)
+  def async_10000(): Boolean = {
+    (1 until 10000).foreach(_ ⇒ client.ping())
+    Await.result(client.ping(), Duration.Inf)
+  }
 
   @Benchmark
-  def sync(): Ping.Ret =
+  def sync(): Boolean =
     Await.result(client.ping(), Duration.Inf)
 }

benchmarks/src/main/scala/rx/redis/RedissonPingBench.scala

@@ -36,8 +36,18 @@ import java.util.concurrent.TimeUnit
 class RedissonPingBench {
 
   @Benchmark
-  def async(s: RedissonPingBench.AsyncState): concurrent.Future[String] =
-    s.conn.ping()
+  @OperationsPerInvocation(10000)
+  def async_10000(s: RedissonPingBench.AsyncState): Boolean = {
+    (1 until 10000).foreach(_ ⇒ s.conn.ping())
+    s.conn.ping().await(1, TimeUnit.MINUTES)
+  }
+
+  @Benchmark
+  @OperationsPerInvocation(100000)
+  def async_100000(s: RedissonPingBench.AsyncState): Boolean = {
+    (1 until 100000).foreach(_ ⇒ s.conn.ping())
+    s.conn.ping().await(1, TimeUnit.MINUTES)
+  }
 
   @Benchmark
   def sync(s: RedissonPingBench.SyncState): String =

benchmarks/src/main/scala/rx/redis/RxPingBench.scala

@@ -46,8 +46,17 @@ class RxPingBench {
   }
 
   @Benchmark
-  def async(): Observable[String] = {
-    client.ping()
+  @OperationsPerInvocation(100000)
+  def async_100000(): String = {
+    (1 until 100000).foreach(_ ⇒ client.ping())
+    client.ping().toBlocking.single()
+  }
+
+  @Benchmark
+  @OperationsPerInvocation(10000)
+  def async_10000(): String = {
+    (1 until 10000).foreach(_ ⇒ client.ping())
+    client.ping().toBlocking.single()
   }
 
   @Benchmark