Rest benchmarks

Author: BartlomiejMichalskiAV

benchmarks/src/main/scala/io/udash/rest/RestApi.scala

@@ -0,0 +1,58 @@
+package io.udash.rest
+
+import io.udash.rest.raw.RawRest
+import monix.eval.Task
+import monix.execution.Scheduler
+import org.openjdk.jmh.annotations.*
+
+import java.util.concurrent.TimeUnit
+import scala.concurrent.Await
+import scala.concurrent.duration.Duration
+
+private object RestApi {
+  trait RestTestApi {
+    @GET def simpleNumbers(size: Int): Task[List[Int]]
+  }
+
+  object RestTestApi extends DefaultRestApiCompanion[RestTestApi] {
+    final class Impl extends RestTestApi {
+
+      def simpleNumbers(size: Int): Task[List[Int]] =
+        Task.eval(Range(0, size).toList)
+    }
+  }
+
+  private def creteApiProxy(): RestTestApi = {
+    val apiImpl = new RestTestApi.Impl()
+    val handler = RawRest.asHandleRequest[RestTestApi](apiImpl)
+    RawRest.fromHandleRequest[RestTestApi](handler)
+  }
+}
+
+
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@BenchmarkMode(Array(Mode.Throughput))
+@State(Scope.Thread)
+class RestApi {
+  implicit def scheduler: Scheduler = Scheduler.global
+  private final val proxy = RestApi.creteApiProxy()
+
+  @Benchmark
+  def smallNumbersArray(): Unit = {
+    waitEndpoint(10)
+  }
+
+  @Benchmark
+  def mediumNumbersArray(): Unit = {
+    waitEndpoint(200)
+  }
+
+  @Benchmark
+  def hugeNumbersArray(): Unit = {
+    waitEndpoint(5000)
+  }
+
+  private def waitEndpoint(samples: Int): Unit = {
+    Await.result(this.proxy.simpleNumbers(samples).runToFuture, Duration.apply(10, TimeUnit.SECONDS))
+  }
+}

benchmarks/src/main/scala/io/udash/rest/StreamingRestApi.scala

@@ -0,0 +1,94 @@
+package io.udash.rest
+
+import io.udash.rest.raw.{RawRest, RestRequest, RestResponse, StreamedRestResponse}
+import monix.eval.Task
+import monix.execution.Scheduler
+import monix.reactive.Observable
+import org.openjdk.jmh.annotations.*
+
+import java.util.concurrent.TimeUnit
+import scala.concurrent.Await
+import scala.concurrent.duration.Duration
+
+private object StreamingRestApi {
+  trait RestTestApi {
+    @GET def simpleNumbers(size: Int): Observable[Int]
+    @GET def simpleNumbersWithoutStreaming(size: Int): Task[List[Int]]
+  }
+
+  object RestTestApi extends DefaultRestApiCompanion[RestTestApi] {
+    final class Impl extends RestTestApi {
+
+      def simpleNumbers(size: Int): Observable[Int] =
+        Observable.fromIterable(Range(0, size))
+
+      def simpleNumbersWithoutStreaming(size: Int): Task[List[Int]] =
+        Task.eval(Range(0, size).toList)
+    }
+  }
+
+  private def creteApiProxy(): RestTestApi = {
+    val apiImpl = new RestTestApi.Impl()
+    val streamingServerHandle = RawRest.asHandleRequestWithStreaming[RestTestApi](apiImpl)
+    val streamingClientHandler = new RawRest.RestRequestHandler {
+      override def handleRequest(request: RestRequest): Task[RestResponse] =
+        streamingServerHandle(request).map(_.asInstanceOf[RestResponse])
+
+      override def handleRequestStream(request: RestRequest): Task[StreamedRestResponse] =
+        streamingServerHandle(request).map(_.asInstanceOf[StreamedRestResponse])
+    }
+    RawRest.fromHandleRequestWithStreaming[RestTestApi](streamingClientHandler)
+  }
+}
+
+
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@BenchmarkMode(Array(Mode.Throughput))
+@State(Scope.Thread)
+class StreamingRestApi {
+  implicit def scheduler: Scheduler = Scheduler.global
+  private final val proxy = StreamingRestApi.creteApiProxy()
+
+
+  @Benchmark
+  def smallNumbersArray(): Unit = {
+    waitStreamingEndpoint(10)
+  }
+
+  @Benchmark
+  def mediumNumbersArray(): Unit = {
+    waitStreamingEndpoint(200)
+  }
+
+  @Benchmark
+  def hugeNumbersArray(): Unit = {
+    waitStreamingEndpoint(5000)
+  }
+
+  @Benchmark
+  def smallNumbersArrayWithoutStreaming(): Unit = {
+    waitEndpointWithoutStreaming(10)
+  }
+
+  @Benchmark
+  def mediumNumbersArrayWithoutStreaming(): Unit = {
+    waitEndpointWithoutStreaming(200)
+  }
+
+  @Benchmark
+  def hugeNumbersArrayWithoutStreaming(): Unit = {
+    waitEndpointWithoutStreaming(5000)
+  }
+
+  private def waitEndpointWithoutStreaming(samples: Int): Unit = {
+    wait(this.proxy.simpleNumbersWithoutStreaming(samples))
+  }
+
+  private def waitStreamingEndpoint(samples: Int): Unit = {
+    wait(this.proxy.simpleNumbers(samples).toListL)
+  }
+
+  private def wait[T](task: Task[List[T]]): Unit = {
+    Await.result(task.runToFuture, Duration.apply(10, TimeUnit.SECONDS))
+  }
+}

build.sbt

@@ -3,6 +3,7 @@ import org.openqa.selenium.firefox.{FirefoxDriverLogLevel, FirefoxOptions}
 import org.scalajs.jsdependencies.sbtplugin.JSModuleID
 import org.scalajs.jsenv.jsdomnodejs.JSDOMNodeJSEnv
 import org.scalajs.jsenv.selenium.SeleniumJSEnv
+import pl.project13.scala.sbt.JmhPlugin
 
 name := "udash"
 
@@ -483,4 +484,12 @@ lazy val `guide-selenium` =
         `guide-homepage` / Compile / compileStatics,
         `guide-guide` / Compile / compileStatics,
       ).value
-    )
+    )
+
+lazy val benchmarksJVM =   project.in(file("benchmarks"))
+  .enablePlugins(JmhPlugin)
+  .dependsOn(jvmLibraries.map(p => p: ClasspathDep[ProjectReference]): _*)
+  .settings(
+    commonSettings,
+    noPublishSettings,
+  )

project/plugins.sbt

@@ -12,4 +12,5 @@ addSbtPlugin("com.github.sbt" % "sbt-native-packager" % "1.11.1")
 
 // Deployment configuration
 addSbtPlugin("com.github.sbt" % "sbt-pgp" % "2.3.1")
-addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "3.12.2")
+addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "3.12.2")
+addSbtPlugin("pl.project13.scala" % "sbt-jmh" % "0.4.7")