Benchmark strings API (#199)

benchmarks/src/main/scala/zio/redis/AppendBenchmarks.scala

+package zio.redis
+
+import java.util.concurrent.TimeUnit
+
+import org.openjdk.jmh.annotations._
+
+import zio.ZIO
+
+@State(Scope.Thread)
+@BenchmarkMode(Array(Mode.Throughput, Mode.AverageTime))
+@OutputTimeUnit(TimeUnit.SECONDS)
+@Measurement(iterations = 15)
+@Warmup(iterations = 15)
+@Fork(2)
+class AppendBenchmarks extends BenchmarkRuntime {
+
+  @Param(Array("500"))
+  private var count: Int = _
+
+  private var items: List[String] = _
+
+  @Setup(Level.Trial)
+  def setup(): Unit = {
+    items = (0 to count).toList.map(_.toString)
+    zioUnsafeRun(ZIO.foreach_(items)(i => set(i, i)))
+  }
+
+  @Benchmark
+  def laserdisc(): Unit = {
+    import _root_.laserdisc.fs2._
+    import _root_.laserdisc.{ all => cmd, _ }
+    import cats.instances.list._
+    import cats.syntax.foldable._
+    unsafeRun[LaserDiscClient](c => items.traverse_(i => c.send(cmd.append(Key.unsafeFrom(i), i))))
+  }
+
+  @Benchmark
+  def rediculous(): Unit = {
+    import cats.implicits._
+    import io.chrisdavenport.rediculous._
+    unsafeRun[RediculousClient](c => items.traverse_(i => RedisCommands.append[RedisIO](i, i).run(c)))
+  }
+
+  @Benchmark
+  def redis4cats(): Unit = {
+    import cats.instances.list._
+    import cats.syntax.foldable._
+    unsafeRun[Redis4CatsClient[String]](c => items.traverse_(i => c.append(i, i)))
+  }
+
+  @Benchmark
+  def zio(): Unit = zioUnsafeRun(ZIO.foreach_(items)(i => append(i, i)))
+}

benchmarks/src/main/scala/zio/redis/BenchmarkRuntime.scala

 package zio.redis
 
-import scala.concurrent.ExecutionContext
-
-import cats.effect.{ ContextShift, Timer, IO => CatsIO }
-import io.chrisdavenport.rediculous.Redis
-
 import zio.BootstrapRuntime
 import zio.internal.Platform
 
-object BenchmarkRuntime extends BootstrapRuntime {
-  implicit val cs: ContextShift[CatsIO] = CatsIO.contextShift(ExecutionContext.global)
-  implicit val timer: Timer[CatsIO]     = CatsIO.timer(ExecutionContext.global)
-
+trait BenchmarkRuntime extends BootstrapRuntime with RedisClients with BenchmarksUtils {
   override val platform: Platform = Platform.benchmark
-
-  type RedisIO[A] = Redis[CatsIO, A]
-
-  final val RedisHost = "127.0.0.1"
-  final val RedisPort = 6379
 }

benchmarks/src/main/scala/zio/redis/BenchmarksUtils.scala

+package zio.redis
+
+import cats.effect.{ IO => CatsIO }
+
+import zio.logging.Logging
+import zio.{ BootstrapRuntime, ZIO }
+
+trait BenchmarksUtils {
+  self: RedisClients with BootstrapRuntime =>
+
+  def unsafeRun[CL](f: CL => CatsIO[Unit])(implicit unsafeRunner: QueryUnsafeRunner[CL]): Unit =
+    unsafeRunner.unsafeRun(f)
+
+  def zioUnsafeRun(source: ZIO[RedisExecutor, RedisError, Unit]): Unit =
+    unsafeRun(source.provideLayer(Logging.ignore >>> RedisExecutor.live(RedisHost, RedisPort).orDie))
+}

benchmarks/src/main/scala/zio/redis/DecrBenchmarks.scala

+package zio.redis
+
+import java.util.concurrent.TimeUnit
+
+import org.openjdk.jmh.annotations._
+
+import zio.ZIO
+
+@State(Scope.Thread)
+@BenchmarkMode(Array(Mode.Throughput, Mode.AverageTime))
+@OutputTimeUnit(TimeUnit.SECONDS)
+@Measurement(iterations = 15)
+@Warmup(iterations = 15)
+@Fork(2)
+class DecrBenchmarks extends BenchmarkRuntime {
+
+  @Param(Array("500"))
+  private var count: Int = _
+
+  private var items: List[String] = _
+
+  @Setup(Level.Trial)
+  def setup(): Unit = {
+    items = (0 to count).toList.map(_.toString)
+    zioUnsafeRun(ZIO.foreach_(items)(i => set(i, i)))
+  }
+
+  @Benchmark
+  def laserdisc(): Unit = {
+    import _root_.laserdisc.fs2._
+    import _root_.laserdisc.{ all => cmd, _ }
+    import cats.instances.list._
+    import cats.syntax.foldable._
+    unsafeRun[LaserDiscClient](c => items.traverse_(i => c.send(cmd.decr[Long](Key.unsafeFrom(i)))))
+  }
+
+  @Benchmark
+  def rediculous(): Unit = {
+    import cats.implicits._
+    import io.chrisdavenport.rediculous._
+    unsafeRun[RediculousClient](c => items.traverse_(i => RedisCommands.decr[RedisIO](i).run(c)))
+  }
+
+  @Benchmark
+  def redis4cats(): Unit = {
+    import cats.instances.list._
+    import cats.syntax.foldable._
+    unsafeRun[Redis4CatsClient[Long]](c => items.traverse_(i => c.decr(i)))
+  }
+
+  @Benchmark
+  def zio(): Unit = zioUnsafeRun(ZIO.foreach_(items)(i => decr(i)))
+}

benchmarks/src/main/scala/zio/redis/GetBenchmarks.scala

+package zio.redis
+
+import java.util.concurrent.TimeUnit
+
+import org.openjdk.jmh.annotations._
+
+import zio.ZIO
+
+@State(Scope.Thread)
+@BenchmarkMode(Array(Mode.Throughput, Mode.AverageTime))
+@OutputTimeUnit(TimeUnit.SECONDS)
+@Measurement(iterations = 15)
+@Warmup(iterations = 15)
+@Fork(2)
+class GetBenchmarks extends BenchmarkRuntime {
+
+  @Param(Array("500"))
+  private var count: Int = _
+
+  private var items: List[String] = _
+
+  @Setup(Level.Trial)
+  def setup(): Unit = {
+    items = (0 to count).toList.map(_.toString)
+    zioUnsafeRun(ZIO.foreach_(items)(i => set(i, i)))
+  }
+
+  @Benchmark
+  def laserdisc(): Unit = {
+    import _root_.laserdisc.fs2._
+    import _root_.laserdisc.{ all => cmd, _ }
+    import cats.instances.list._
+    import cats.syntax.foldable._
+    unsafeRun[LaserDiscClient](c => items.traverse_(i => c.send(cmd.get[String](Key.unsafeFrom(i)))))
+  }
+
+  @Benchmark
+  def rediculous(): Unit = {
+    import cats.implicits._
+    import io.chrisdavenport.rediculous._
+    unsafeRun[RediculousClient](c => items.traverse_(i => RedisCommands.get[RedisIO](i).run(c)))
+  }
+
+  @Benchmark
+  def redis4cats(): Unit = {
+    import cats.instances.list._
+    import cats.syntax.foldable._
+    unsafeRun[Redis4CatsClient[String]](c => items.traverse_(i => c.get(i)))
+  }
+
+  @Benchmark
+  def zio(): Unit = zioUnsafeRun(ZIO.foreach_(items)(get))
+}

benchmarks/src/main/scala/zio/redis/GetBitBenchmarks.scala

+package zio.redis
+
+import java.util.concurrent.TimeUnit
+
+import org.openjdk.jmh.annotations._
+
+import zio.ZIO
+
+@State(Scope.Thread)
+@BenchmarkMode(Array(Mode.Throughput, Mode.AverageTime))
+@OutputTimeUnit(TimeUnit.SECONDS)
+@Measurement(iterations = 15)
+@Warmup(iterations = 15)
+@Fork(2)
+class GetBitBenchmarks extends BenchmarkRuntime {
+
+  @Param(Array("500"))
+  private var count: Int = _
+
+  private var items: List[String] = _
+
+  @Setup(Level.Trial)
+  def setup(): Unit = {
+    items = (0 to count).toList.map(_.toString)
+    zioUnsafeRun(ZIO.foreach_(items)(i => set(i, i)))
+  }
+
+  @Benchmark
+  def laserdisc(): Unit = {
+    import _root_.laserdisc.fs2._
+    import _root_.laserdisc.{ all => cmd, _ }
+    import cats.instances.list._
+    import cats.syntax.foldable._
+    unsafeRun[LaserDiscClient](c => items.traverse_(i => c.send(cmd.getbit(Key.unsafeFrom(i), PosLong.unsafeFrom(0L)))))
+  }
+
+  @Benchmark
+  def rediculous(): Unit = {
+    import cats.implicits._
+    import io.chrisdavenport.rediculous._
+    unsafeRun[RediculousClient](c => items.traverse_(i => RedisCommands.getbit[RedisIO](i, 0L).run(c)))
+  }
+
+  @Benchmark
+  def redis4cats(): Unit = {
+    import cats.instances.list._
+    import cats.syntax.foldable._
+    unsafeRun[Redis4CatsClient[String]](c => items.traverse_(i => c.getBit(i, 0L)))
+  }
+
+  @Benchmark
+  def zio(): Unit = zioUnsafeRun(ZIO.foreach_(items)(i => getBit(i, 0L)))
+}

benchmarks/src/main/scala/zio/redis/IncrBenchmarks.scala

+package zio.redis
+
+import java.util.concurrent.TimeUnit
+
+import org.openjdk.jmh.annotations._
+
+import zio.ZIO
+
+@State(Scope.Thread)
+@BenchmarkMode(Array(Mode.Throughput, Mode.AverageTime))
+@OutputTimeUnit(TimeUnit.SECONDS)
+@Measurement(iterations = 15)
+@Warmup(iterations = 15)
+@Fork(2)
+class IncrBenchmarks extends BenchmarkRuntime {
+
+  @Param(Array("500"))
+  private var count: Int = _
+
+  private var items: List[String] = _
+
+  @Setup(Level.Trial)
+  def setup(): Unit = {
+    items = (0 to count).toList.map(_.toString)
+    zioUnsafeRun(ZIO.foreach_(items)(i => set(i, i)))
+  }
+
+  @Benchmark
+  def laserdisc(): Unit = {
+    import _root_.laserdisc.fs2._
+    import _root_.laserdisc.{ all => cmd, _ }
+    import cats.instances.list._
+    import cats.syntax.foldable._
+
+    unsafeRun[LaserDiscClient](c => items.traverse_(i => c.send(cmd.incr[Long](Key.unsafeFrom(i)))))
+  }
+
+  @Benchmark
+  def rediculous(): Unit = {
+    import cats.implicits._
+    import io.chrisdavenport.rediculous._
+    unsafeRun[RediculousClient](c => items.traverse_(i => RedisCommands.append[RedisIO](i, i).run(c)))
+  }
+
+  @Benchmark
+  def redis4cats(): Unit = {
+    import cats.instances.list._
+    import cats.syntax.foldable._
+    unsafeRun[Redis4CatsClient[Long]](c => items.traverse_(i => c.incr(i)))
+  }
+
+  @Benchmark
+  def zio(): Unit = zioUnsafeRun(ZIO.foreach_(items)(i => incr(i)))
+}

benchmarks/src/main/scala/zio/redis/RedisClients.scala

+package zio.redis
+
+import scala.concurrent.ExecutionContext
+
+import cats.effect.{ Blocker, ContextShift, Resource, Timer, IO => CatsIO }
+import dev.profunktor.redis4cats.RedisCommands
+import dev.profunktor.redis4cats.data.RedisCodec
+import fs2.io.tcp.SocketGroup
+import io.chrisdavenport.rediculous.{ Redis, RedisConnection }
+import io.lettuce.core.ClientOptions
+import laserdisc.fs2.RedisClient
+
+trait RedisClients {
+
+  implicit val cs: ContextShift[CatsIO] = CatsIO.contextShift(ExecutionContext.global)
+  implicit val timer: Timer[CatsIO]     = CatsIO.timer(ExecutionContext.global)
+
+  final val RedisHost = "127.0.0.1"
+  final val RedisPort = 6379
+
+  type RedisIO[A] = Redis[CatsIO, A]
+
+  type Redis4CatsClient[V] = RedisCommands[CatsIO, String, V]
+  type LaserDiscClient     = RedisClient[CatsIO]
+  type RediculousClient    = RedisConnection[CatsIO]
+
+  trait QueryUnsafeRunner[F] {
+    def unsafeRun(f: F => CatsIO[Unit]): Unit
+  }
+
+  implicit object LaserDiscClientRunner extends QueryUnsafeRunner[LaserDiscClient] {
+    override def unsafeRun(f: LaserDiscClient => CatsIO[Unit]): Unit = laserDiskConnection.use(f).unsafeRunSync
+  }
+
+  implicit object RedicoulusClientRunner extends QueryUnsafeRunner[RediculousClient] {
+    override def unsafeRun(f: RediculousClient => CatsIO[Unit]): Unit = redicoulusConnection.use(f).unsafeRunSync
+  }
+
+  implicit object Redis4CatsClientRunnerString extends QueryUnsafeRunner[Redis4CatsClient[String]] {
+    override def unsafeRun(f: Redis4CatsClient[String] => CatsIO[Unit]): Unit =
+      redis4CatsConnectionString.use(f).unsafeRunSync
+  }
+
+  implicit object Redis4CatsClientRunnerLong extends QueryUnsafeRunner[Redis4CatsClient[Long]] {
+    override def unsafeRun(f: Redis4CatsClient[Long] => CatsIO[Unit]): Unit =
+      redis4CatsConnectionLong.use(f).unsafeRunSync
+  }
+
+  private val redicoulusConnection: Resource[CatsIO, RediculousClient] =
+    for {
+      blocker <- Blocker[CatsIO]
+      sg      <- SocketGroup[CatsIO](blocker)
+      c       <- RedisConnection.queued[CatsIO](sg, RedisHost, RedisPort, maxQueued = 10000, workers = 2)
+    } yield c
+
+  import _root_.laserdisc.auto.autoRefine
+  private val laserDiskConnection: Resource[CatsIO, LaserDiscClient] = RedisClient.to(RedisHost, RedisPort)
+
+  import dev.profunktor.redis4cats.Redis
+  import dev.profunktor.redis4cats.effect.Log.NoOp.instance
+  private val redis4CatsConnectionString: Resource[CatsIO, RedisCommands[CatsIO, String, String]] =
+    Redis[CatsIO].utf8(s"redis://$RedisHost:$RedisPort")
+
+  private val redis4CatsConnectionLong: Resource[CatsIO, RedisCommands[CatsIO, String, Long]] = {
+    import dev.profunktor.redis4cats.codecs.Codecs
+    import dev.profunktor.redis4cats.codecs.splits._
+
+    val longCodec: RedisCodec[String, Long] = Codecs.derive(RedisCodec.Utf8, stringLongEpi)
+    Redis[CatsIO].withOptions(s"redis://$RedisHost:$RedisPort", ClientOptions.create(), longCodec)
+  }
+}

benchmarks/src/main/scala/zio/redis/PutBenchmarks.scala → benchmarks/src/main/scala/zio/redis/SetBenchmarks.scala

@@ -5,16 +5,14 @@ import java.util.concurrent.TimeUnit
 import org.openjdk.jmh.annotations._
 
 import zio.ZIO
-import zio.logging.Logging
 
 @State(Scope.Thread)
-@BenchmarkMode(Array(Mode.Throughput))
+@BenchmarkMode(Array(Mode.Throughput, Mode.AverageTime))
 @OutputTimeUnit(TimeUnit.SECONDS)
-@Measurement(iterations = 15, timeUnit = TimeUnit.SECONDS, time = 3)
-@Warmup(iterations = 15, timeUnit = TimeUnit.SECONDS, time = 3)
-@Fork(3)
-class PutBenchmarks {
-  import BenchmarkRuntime._
+@Measurement(iterations = 10)
+@Warmup(iterations = 5)
+@Fork(2)
+class SetBenchmarks extends BenchmarkRuntime {
 
   @Param(Array("500"))
   private var count: Int = _
@@ -27,57 +25,28 @@ class PutBenchmarks {
 
   @Benchmark
   def laserdisc(): Unit = {
-    import _root_.laserdisc.auto._
     import _root_.laserdisc.fs2._
     import _root_.laserdisc.{ all => cmd, _ }
     import cats.instances.list._
     import cats.syntax.foldable._
 
-    RedisClient
-      .to(RedisHost, RedisPort)
-      .use(c => items.traverse_(i => c.send(cmd.set(Key.unsafeFrom(i), i))))
-      .unsafeRunSync
+    unsafeRun[LaserDiscClient](c => items.traverse_(i => c.send(cmd.set(Key.unsafeFrom(i), i))))
   }
 
   @Benchmark
   def rediculous(): Unit = {
-    import cats.effect._
     import cats.implicits._
-    import fs2.io.tcp._
     import io.chrisdavenport.rediculous._
-
-    val connection =
-      for {
-        blocker <- Blocker[IO]
-        sg      <- SocketGroup[IO](blocker)
-        c       <- RedisConnection.queued[IO](sg, RedisHost, RedisPort, maxQueued = 10000, workers = 2)
-      } yield c
-
-    connection
-      .use(c => items.traverse_(i => RedisCommands.set[RedisIO](i, i).run(c)))
-      .unsafeRunSync
+    unsafeRun[RediculousClient](c => items.traverse_(i => RedisCommands.set[RedisIO](i, i).run(c)))
   }
 
   @Benchmark
   def redis4cats(): Unit = {
-    import cats.effect.IO
     import cats.instances.list._
     import cats.syntax.foldable._
-    import dev.profunktor.redis4cats.Redis
-    import dev.profunktor.redis4cats.effect.Log.NoOp._
-
-    Redis[IO]
-      .utf8(s"redis://$RedisHost:$RedisPort")
-      .use(c => items.traverse_(i => c.set(i, i)))
-      .unsafeRunSync
+    unsafeRun[Redis4CatsClient[String]](c => items.traverse_(i => c.set(i, i)))
   }
 
   @Benchmark
-  def zio(): Unit = {
-    val effect = ZIO
-      .foreach_(items)(i => set(i, i, None, None, None))
-      .provideLayer(Logging.ignore >>> RedisExecutor.live(RedisHost, RedisPort).orDie)
-
-    unsafeRun(effect)
-  }
+  def zio(): Unit = zioUnsafeRun(ZIO.foreach_(items)(i => set(i, i)))
 }

benchmarks/src/main/scala/zio/redis/StrLenBenchmarks.scala

+package zio.redis
+
+import java.util.concurrent.TimeUnit
+
+import org.openjdk.jmh.annotations._
+
+import zio.ZIO
+
+@State(Scope.Thread)
+@BenchmarkMode(Array(Mode.Throughput, Mode.AverageTime))
+@OutputTimeUnit(TimeUnit.SECONDS)
+@Measurement(iterations = 15)
+@Warmup(iterations = 15)
+@Fork(2)
+class StrLenBenchmarks extends BenchmarkRuntime {
+
+  @Param(Array("500"))
+  private var count: Int = _
+
+  private var items: List[String] = _
+
+  @Setup(Level.Trial)
+  def setup(): Unit = {
+    items = (0 to count).toList.map(_.toString)
+    zioUnsafeRun(ZIO.foreach_(items)(i => set(i, i)))
+  }
+
+  @Benchmark
+  def laserdisc(): Unit = {
+    import _root_.laserdisc.fs2._
+    import _root_.laserdisc.{ all => cmd, _ }
+    import cats.instances.list._
+    import cats.syntax.foldable._
+    unsafeRun[LaserDiscClient](c => items.traverse_(i => c.send(cmd.strlen(Key.unsafeFrom(i)))))
+  }
+
+  @Benchmark
+  def rediculous(): Unit = {
+    import cats.implicits._
+    import io.chrisdavenport.rediculous._
+    unsafeRun[RediculousClient](c => items.traverse_(i => RedisCommands.strlen[RedisIO](i).run(c)))
+  }
+
+  @Benchmark
+  def redis4cats(): Unit = {
+    import cats.instances.list._
+    import cats.syntax.foldable._
+    unsafeRun[Redis4CatsClient[String]](c => items.traverse_(i => c.strLen(i)))
+  }
+
+  @Benchmark
+  def zio(): Unit = zioUnsafeRun(ZIO.foreach_(items)(strLen))
+}