Rest benchmarks

Author: BartlomiejMichalskiAV

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

@@ -11,14 +11,14 @@ import scala.concurrent.duration.Duration
 
 private object RestApi {
   trait RestTestApi {
-    @GET def simpleNumbers(size: Int): Task[List[Int]]
+    @GET def exampleEndpoint(size: Int): Task[List[RestExampleData]]
   }
 
   object RestTestApi extends DefaultRestApiCompanion[RestTestApi] {
     final class Impl extends RestTestApi {
 
-      def simpleNumbers(size: Int): Task[List[Int]] =
-        Task.eval(Range(0, size).toList)
+      def exampleEndpoint(size: Int): Task[List[RestExampleData]] =
+        RestExampleData.generateRandomList(size)
     }
   }
 
@@ -30,29 +30,29 @@ private object RestApi {
 }
 
 
-@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@OutputTimeUnit(TimeUnit.SECONDS)
 @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 = {
+  def smallArray(): Unit = {
     waitEndpoint(10)
   }
 
   @Benchmark
-  def mediumNumbersArray(): Unit = {
+  def mediumArray(): Unit = {
     waitEndpoint(200)
   }
 
   @Benchmark
-  def hugeNumbersArray(): Unit = {
+  def hugeArray(): Unit = {
     waitEndpoint(5000)
   }
 
   private def waitEndpoint(samples: Int): Unit = {
-    Await.result(this.proxy.simpleNumbers(samples).runToFuture, Duration.apply(10, TimeUnit.SECONDS))
+    Await.result(this.proxy.exampleEndpoint(samples).runToFuture, Duration.apply(10, TimeUnit.SECONDS))
   }
 }

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

@@ -0,0 +1,24 @@
+package io.udash.rest
+
+import monix.eval.Task
+import monix.reactive.Observable
+
+import scala.util.Random
+
+case class RestExampleData(number: Long, string: String)
+
+object RestExampleData extends RestDataCompanion[RestExampleData]{
+  private def random() = {
+    RestExampleData(
+      Random.nextLong(),
+      Iterator.continually(Random.nextPrintableChar()).take(200).mkString
+    )
+  }
+
+  def generateRandomObservable(size: Int): Observable[RestExampleData] =
+    Observable.fromIterable(Range(0, size).map(_ => RestExampleData.random()))
+
+  def generateRandomList(size: Int): Task[List[RestExampleData]] =
+    Task.eval(Range(0, size).toList.map(_ => RestExampleData.random()))
+
+}

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

@@ -12,18 +12,31 @@ 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]]
+    @GET def exampleEndpoint(size: Int): Observable[RestExampleData]
+
+    @streamingResponseBatchSize(10)
+    @GET def exampleEndpointBatch10(size: Int): Observable[RestExampleData]
+
+    @streamingResponseBatchSize(500)
+    @GET def exampleEndpointBatch500(size: Int): Observable[RestExampleData]
+
+    @GET def exampleEndpointWithoutStreaming(size: Int): Task[List[RestExampleData]]
   }
 
   object RestTestApi extends DefaultRestApiCompanion[RestTestApi] {
     final class Impl extends RestTestApi {
 
-      def simpleNumbers(size: Int): Observable[Int] =
-        Observable.fromIterable(Range(0, size))
+      def exampleEndpoint(size: Int): Observable[RestExampleData] =
+        RestExampleData.generateRandomObservable(size)
 
-      def simpleNumbersWithoutStreaming(size: Int): Task[List[Int]] =
-        Task.eval(Range(0, size).toList)
+      def exampleEndpointBatch10(size: Int): Observable[RestExampleData] =
+        RestExampleData.generateRandomObservable(size)
+
+      def exampleEndpointBatch500(size: Int): Observable[RestExampleData] =
+        RestExampleData.generateRandomObservable(size)
+
+      def exampleEndpointWithoutStreaming(size: Int): Task[List[RestExampleData]] =
+        RestExampleData.generateRandomList(size)
     }
   }
 
@@ -51,41 +64,71 @@ class StreamingRestApi {
 
 
   @Benchmark
-  def smallNumbersArray(): Unit = {
+  def smallArray(): Unit = {
     waitStreamingEndpoint(10)
   }
 
   @Benchmark
-  def mediumNumbersArray(): Unit = {
+  def mediumArray(): Unit = {
     waitStreamingEndpoint(200)
   }
 
   @Benchmark
-  def hugeNumbersArray(): Unit = {
+  def hugeArray(): Unit = {
     waitStreamingEndpoint(5000)
   }
 
   @Benchmark
-  def smallNumbersArrayWithoutStreaming(): Unit = {
+  def smallArrayBatch10(): Unit = {
+    wait(this.proxy.exampleEndpointBatch10(10).toListL)
+  }
+
+  @Benchmark
+  def mediumArrayBatch10(): Unit = {
+    wait(this.proxy.exampleEndpointBatch10(200).toListL)
+  }
+
+  @Benchmark
+  def hugeArrayBatch10(): Unit = {
+    wait(this.proxy.exampleEndpointBatch10(5000).toListL)
+  }
+
+  @Benchmark
+  def smallArrayBatch500(): Unit = {
+    wait(this.proxy.exampleEndpointBatch500(10).toListL)
+  }
+
+  @Benchmark
+  def mediumArrayBatch500(): Unit = {
+    wait(this.proxy.exampleEndpointBatch500(200).toListL)
+  }
+
+  @Benchmark
+  def hugeArrayBatch500(): Unit = {
+    wait(this.proxy.exampleEndpointBatch500(5000).toListL)
+  }
+
+  @Benchmark
+  def smallArrayWithoutStreaming(): Unit = {
     waitEndpointWithoutStreaming(10)
   }
 
   @Benchmark
-  def mediumNumbersArrayWithoutStreaming(): Unit = {
+  def mediumArrayWithoutStreaming(): Unit = {
     waitEndpointWithoutStreaming(200)
   }
 
   @Benchmark
-  def hugeNumbersArrayWithoutStreaming(): Unit = {
+  def hugeArrayWithoutStreaming(): Unit = {
     waitEndpointWithoutStreaming(5000)
   }
 
   private def waitEndpointWithoutStreaming(samples: Int): Unit = {
-    wait(this.proxy.simpleNumbersWithoutStreaming(samples))
+    wait(this.proxy.exampleEndpointWithoutStreaming(samples))
   }
 
   private def waitStreamingEndpoint(samples: Int): Unit = {
-    wait(this.proxy.simpleNumbers(samples).toListL)
+    wait(this.proxy.exampleEndpoint(samples).toListL)
   }
 
   private def wait[T](task: Task[List[T]]): Unit = {