Fixed according to the code review

Author: fmixing

benchmarks/plots-generators/generate-flatten-merge-flow-plots.py

@@ -1,54 +1,51 @@
 import pandas as pd
-import random
 import matplotlib.pyplot as plt
 from matplotlib.ticker import FormatStrFormatter
-from matplotlib.colors import ListedColormap
-from matplotlib.backends.backend_pdf import PdfPages
 
 inputFile = "jmh-result.csv"
-outputFile = "flatten-merge-plots.pdf"
+outputFile = "flatten-merge-plots.svg"
 elements = 10000
-flattenMergeBenchmarkName="benchmarks.flow.FlattenMergeBenchmark.flattenMerge"
-
-def nextColour():
-    colours = ['black', 'silver', 'red', 'gold', 'sienna', 'olivedrab', 'lightseagreen', 'navy', 'blue', 'm', 'crimson', 'yellow', 'orangered', 'slateblue', 'aqua']
-
-    for colour in colours:
-        yield colour
-
-def nextMarker():
-    markers = ['.', 'v', '^', '1', '2', '8', 'p', 'P', 'x', 'D', 'd', 's']
-
-    for marker in markers:
-        yield marker
-
-def draw(data, ax):
-    data = data[(data.benchmark == flattenMergeBenchmarkName)]
-
-    ax.set_xscale('log', basex=2)
-    ax.xaxis.set_major_formatter(FormatStrFormatter('%0.f'))
-    ax.grid(linewidth='0.5', color='lightgray')
-    ax.set_ylabel(data.unit.unique()[0])
-    ax.set_xlabel('parallelism')
-    ax.set_xticks(data.concurrency.unique())
-
-    colourGen = nextColour()
-    markerGen = nextMarker()
+benchmarkName="benchmarks.flow.FlattenMergeBenchmark.flattenMerge"
+
+markers = ['.', 'v', '^', '1', '2', '8', 'p', 'P', 'x', 'D', 'd', 's']
+colours = ['black', 'silver', 'red', 'gold', 'sienna', 'olivedrab', 'lightseagreen', 'navy', 'blue', 'm', 'crimson', 'yellow', 'orangered', 'slateblue', 'aqua']
+
+def next_colour():
+    i = 0
+    while True:
+        yield colours[i % len(colours)]
+        i += 1
+
+def next_marker():
+    i = 0
+    while True:
+        yield markers[i % len(markers)]
+        i += 1
+
+def draw(data, plt):
+    data = data[(data.benchmark == benchmarkName)]
+
+    plt.xscale('log', basex=2)
+    plt.gca().xaxis.set_major_formatter(FormatStrFormatter('%0.f'))
+    plt.grid(linewidth='0.5', color='lightgray')
+    plt.ylabel(data.unit.unique()[0])
+    plt.xlabel('parallelism')
+    plt.xticks(data.concurrency.unique())
+
+    colourGen = next_colour()
+    markerGen = next_marker()
     for flows in data.flows.unique():
         genColour = next(colourGen)
         genMarker = next(markerGen)
         res = data[(data.flows == flows)]
-        ax.plot(res.concurrency, res.score*elements, label="flows={}".format(flows), color=genColour, marker=genMarker)
+        plt.plot(res.concurrency, res.score*elements, label="flows={}".format(flows), color=genColour, marker=genMarker)
 
-def genFile(pdf):
+def genFile():
     data = pd.read_table(inputFile, sep=",", skiprows=1, names=["benchmark","mode","threads","samples","score","scoreError","unit","concurrency","flows"])
-    fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(20, 20))
-    draw(data, ax)
-    lines, labels = ax.get_legend_handles_labels()
-    fig.legend(lines, labels, loc='upper center', borderpad=0, ncol=4, frameon=False, borderaxespad=4, prop={'size': 8})
-
+    plt.figure(figsize=(20, 20))
+    draw(data, plt)
+    plt.legend(loc='upper center', borderpad=0, ncol=4, frameon=False, borderaxespad=4, prop={'size': 8})
     plt.tight_layout(pad=12, w_pad=2, h_pad=1)
-    pdf.savefig(bbox_inches='tight')
+    plt.savefig(outputFile, bbox_inches='tight')
 
-with PdfPages(outputFile) as pdf:
-    genFile(pdf)
+genFile()

benchmarks/src/jmh/kotlin/benchmarks/SemaphoreBenchmark.kt

@@ -83,7 +83,7 @@ enum class SemaphoreBenchDispatcherCreator(val create: (parallelism: Int) -> Cor
     EXPERIMENTAL({ parallelism -> ExperimentalCoroutineDispatcher(corePoolSize = parallelism, maxPoolSize = parallelism) })
 }
 
-private fun doWork(work: Int) {
+fun doWork(work: Int) {
     // We use geometric distribution here
     val p = 1.0 / work
     val r = ThreadLocalRandom.current()

benchmarks/src/jmh/kotlin/benchmarks/flow/FlattenMergeBenchmark.kt

@@ -1,8 +1,10 @@
 package benchmarks.flow
 
+import benchmarks.doWork
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
 import org.openjdk.jmh.annotations.*
+import java.util.concurrent.ThreadLocalRandom
 import java.util.concurrent.TimeUnit
 import kotlin.math.ceil
 
@@ -33,16 +35,13 @@ open class FlattenMergeBenchmark {
 
     @Setup
     fun setup() {
-        val flowsNumber = if (flows < 0) {
-            -flows * concurrency
-        }
-        else {
-            flows
-        }
+        val flowsNumber = if (flows >= 0) flows else -(flows * concurrency)
+        val flowElementsToProcess = ceil(ELEMENTS / flowsNumber.toDouble())
 
         flow = (1..flowsNumber).asFlow().map {
             flow {
-                repeat(ceil(ELEMENTS / flowsNumber.toDouble()).toInt()) {
+                repeat(flowElementsToProcess.toInt()) {
+                    doWork(WORK)
                     emit(it)
                 }
             }
@@ -55,4 +54,5 @@ open class FlattenMergeBenchmark {
     }
 }
 
-private const val ELEMENTS = 10_000
+private const val ELEMENTS = 100_000
+private const val WORK = 80