Replace usages of the word "optimized" for the R2DBC configs with "ktor-r2dbc"

ShreckYe · ShreckYe · commit cfd08e5f5fda · 2026-02-26T20:31:36.000+08:00
diff --git a/frameworks/Kotlin/vertx-web-kotlinx/benchmark_config.json b/frameworks/Kotlin/vertx-web-kotlinx/benchmark_config.json
@@ -124,7 +124,6 @@
         "os": "Linux",
         "database_os": "Linux",
         "display_name": "vertx-web-kotlinx-exposed-r2dbc-postgresql",
-        "notes": "Alias for shared-pool-size-512-optimized configuration",
         "versus": "vertx-web-kotlinx-r2dbc-postgresql"
       },
       "exposed-vertx-sql-client-postgresql": {
diff --git a/frameworks/Kotlin/vertx-web-kotlinx/with-db/exposed-r2dbc/src/main/kotlin/Main.kt b/frameworks/Kotlin/vertx-web-kotlinx/with-db/exposed-r2dbc/src/main/kotlin/Main.kt
@@ -4,34 +4,34 @@ suspend fun main(args: Array<String>) {
     // Parse CLI arguments
     val isSharedPool = args.getOrNull(0)?.toBooleanStrictOrNull() ?: false
     val poolSize = args.getOrNull(1)?.toIntOrNull() ?: 8
-    val useOptimizedConfig = args.getOrNull(2)?.toBooleanStrictOrNull() ?: false
+    val useKtorR2dbcConfig = args.getOrNull(2)?.toBooleanStrictOrNull() ?: false
 
     val benchmarkName = buildString {
         append("Vert.x-Web Kotlinx with Exposed R2DBC (and PostgreSQL)")
-        if (!isSharedPool || poolSize != 512 || !useOptimizedConfig) {
+        if (!isSharedPool || poolSize != 512 || !useKtorR2dbcConfig) {
             append(" - ")
             if (isSharedPool) {
                 append("Shared Pool Size $poolSize")
             } else {
                 append("Separate Pool Size $poolSize")
             }
-            if (useOptimizedConfig) {
-                append(" Optimized")
+            if (useKtorR2dbcConfig) {
+                append(" Ktor R2DBC portion config")
             }
         }
     }
 
     if (isSharedPool) {
         commonRunVertxServer(
             benchmarkName,
-            { r2dbcConnectPool(poolSize, useOptimizedConfig) },
+            { r2dbcConnectPool(poolSize, useKtorR2dbcConfig) },
             ::MainVerticle
         )
     } else {
         commonRunVertxServer(
             benchmarkName,
             { Unit },
-            { MainVerticleWithSeparatePool(poolSize, useOptimizedConfig) }
+            { MainVerticleWithSeparatePool(poolSize, useKtorR2dbcConfig) }
         )
     }
 }
diff --git a/frameworks/Kotlin/vertx-web-kotlinx/with-db/exposed-r2dbc/src/main/kotlin/MainVerticle.kt b/frameworks/Kotlin/vertx-web-kotlinx/with-db/exposed-r2dbc/src/main/kotlin/MainVerticle.kt
@@ -52,5 +52,5 @@ class MainVerticle(private val r2dbcDatabase: R2dbcDatabase) : CommonWithDbVerti
  * Creates a MainVerticle that will create its own connection pool per verticle instance.
  * Used for separate-pool benchmark configurations.
  */
-fun MainVerticleWithSeparatePool(poolSize: Int, useOptimizedConfig: Boolean): MainVerticle =
-    MainVerticle(r2dbcConnectPool(poolSize, useOptimizedConfig))
+fun MainVerticleWithSeparatePool(poolSize: Int, useKtorR2dbcConfig: Boolean): MainVerticle =
+    MainVerticle(r2dbcConnectPool(poolSize, useKtorR2dbcConfig))
diff --git a/frameworks/Kotlin/vertx-web-kotlinx/with-db/exposed-r2dbc/src/main/kotlin/database/ExposedDatabaseR2dbc.kt b/frameworks/Kotlin/vertx-web-kotlinx/with-db/exposed-r2dbc/src/main/kotlin/database/ExposedDatabaseR2dbc.kt
@@ -10,17 +10,17 @@ fun r2dbcDatabaseConnectPoolOriginal(connectionPoolSize: Int) =
         explicitDialect = PostgreSQLDialect()
     })
 
-fun r2dbcDatabaseConnectPoolOptimized(connectionPoolSize: Int) =
-    R2dbcDatabase.connect(connectionPoolOptimized(connectionPoolSize), R2dbcDatabaseConfig {
+fun r2dbcDatabaseConnectPoolKtorR2dbc(connectionPoolSize: Int) =
+    R2dbcDatabase.connect(connectionPoolKtorR2dbc(connectionPoolSize), R2dbcDatabaseConfig {
         explicitDialect = PostgreSQLDialect()
     })
 
 /**
  * Creates a shared R2dbcDatabase instance with a connection pool.
  * Used for shared-pool benchmark configurations.
  */
-fun r2dbcConnectPool(poolSize: Int, useOptimizedConfig: Boolean): R2dbcDatabase =
-    if (useOptimizedConfig)
-        r2dbcDatabaseConnectPoolOptimized(poolSize)
+fun r2dbcConnectPool(poolSize: Int, useKtorR2dbcConfig: Boolean): R2dbcDatabase =
+    if (useKtorR2dbcConfig)
+        r2dbcDatabaseConnectPoolKtorR2dbc(poolSize)
     else
         r2dbcDatabaseConnectPoolOriginal(poolSize)
diff --git a/frameworks/Kotlin/vertx-web-kotlinx/with-db/r2dbc-common/src/main/kotlin/database/R2dbcKtorR2dbc.kt b/frameworks/Kotlin/vertx-web-kotlinx/with-db/r2dbc-common/src/main/kotlin/database/R2dbcKtorR2dbc.kt
@@ -8,8 +8,9 @@ import io.r2dbc.postgresql.client.SSLMode
 import io.r2dbc.spi.ConnectionFactory
 import java.time.Duration
 
-// Optimized configuration with TCP settings and connection validation
-val connectionFactoryOptimized: ConnectionFactory = PostgresqlConnectionFactory(
+// Alternative configurations copied from the `ktor-r2dbc` portion. These configurations don't lead to better performance as tested in Continuous Benchmarking.
+
+val connectionFactoryKtorR2dbc: ConnectionFactory = PostgresqlConnectionFactory(
     PostgresqlConnectionConfiguration.builder()
         .host(HOST)
         .port(5432)
@@ -22,14 +23,13 @@ val connectionFactoryOptimized: ConnectionFactory = PostgresqlConnectionFactory(
         .build()
 )
 
-fun connectionPoolConfigurationOptimized(size: Int) =
-    ConnectionPoolConfiguration.builder(connectionFactoryOptimized)
+fun connectionPoolConfigurationKtorR2dbc(size: Int) =
+    ConnectionPoolConfiguration.builder(connectionFactoryKtorR2dbc)
         .initialSize(size)
         .maxSize(size)
         .maxIdleTime(Duration.ofSeconds(30))
         .maxAcquireTime(Duration.ofSeconds(5))
-        .validationQuery("SELECT 1")
         .build()
 
-fun connectionPoolOptimized(size: Int) =
-    ConnectionPool(connectionPoolConfigurationOptimized(size))
+fun connectionPoolKtorR2dbc(size: Int) =
+    ConnectionPool(connectionPoolConfigurationKtorR2dbc(size))
diff --git a/frameworks/Kotlin/vertx-web-kotlinx/with-db/r2dbc/src/main/kotlin/Main.kt b/frameworks/Kotlin/vertx-web-kotlinx/with-db/r2dbc/src/main/kotlin/Main.kt
@@ -1,4 +1,4 @@
-import database.connectionPoolOptimized
+import database.connectionPoolKtorR2dbc
 import database.connectionPoolOriginal
 import io.r2dbc.spi.ConnectionFactory
 
@@ -7,27 +7,27 @@ suspend fun main(args: Array<String>) {
     val isSharedPool = args.getOrNull(0)?.toBooleanStrictOrNull() ?: false
     val poolSize = args.getOrNull(1)?.toIntOrNull()
         ?: 8 // TODO `1` might produce equivalent results because there is no transaction in this portion compared to `exposed-r2dbc`.
-    val useOptimizedConfig = args.getOrNull(2)?.toBooleanStrictOrNull() ?: false
+    val useKtorR2dbcConfig = args.getOrNull(2)?.toBooleanStrictOrNull() ?: false
 
     val benchmarkName = buildString {
         append("Vert.x-Web Kotlinx with R2DBC (and PostgreSQL)")
-        if (!isSharedPool || poolSize != 512 || !useOptimizedConfig) {
+        if (!isSharedPool || poolSize != 512 || !useKtorR2dbcConfig) {
             append(" - ")
             if (isSharedPool) {
                 append("Shared Pool Size $poolSize")
             } else {
                 append("Separate Pool Size $poolSize")
             }
-            if (useOptimizedConfig) {
-                append(" Optimized")
+            if (useKtorR2dbcConfig) {
+                append(" Ktor R2DBC portion config")
             }
         }
     }
 
     if (isSharedPool) {
         // Shared pool: create one ConnectionPool that all verticles will share
-        val connectionFactory: ConnectionFactory = if (useOptimizedConfig) {
-            connectionPoolOptimized(poolSize)
+        val connectionFactory: ConnectionFactory = if (useKtorR2dbcConfig) {
+            connectionPoolKtorR2dbc(poolSize)
         } else {
             connectionPoolOriginal(poolSize)
         }
@@ -42,7 +42,7 @@ suspend fun main(args: Array<String>) {
         commonRunVertxServer(
             benchmarkName,
             {},
-            { MainVerticleWithSeparatePool(poolSize, useOptimizedConfig) }
+            { MainVerticleWithSeparatePool(poolSize, useKtorR2dbcConfig) }
         )
     }
 }
diff --git a/frameworks/Kotlin/vertx-web-kotlinx/with-db/r2dbc/src/main/kotlin/MainVerticle.kt b/frameworks/Kotlin/vertx-web-kotlinx/with-db/r2dbc/src/main/kotlin/MainVerticle.kt
@@ -56,9 +56,9 @@ class MainVerticle(private val connectionFactory: ConnectionFactory) : CommonWit
 }
 
 // Factory function for creating MainVerticle with separate connection pools
-fun MainVerticleWithSeparatePool(poolSize: Int, useOptimizedConfig: Boolean): MainVerticle {
-    val connectionPool = if (useOptimizedConfig) {
-        connectionPoolOptimized(poolSize)
+fun MainVerticleWithSeparatePool(poolSize: Int, useKtorR2dbcConfig: Boolean): MainVerticle {
+    val connectionPool = if (useKtorR2dbcConfig) {
+        connectionPoolKtorR2dbc(poolSize)
     } else {
         connectionPoolOriginal(poolSize)
     }

Original file line number	Diff line number	Diff line change
`@@ -4,34 +4,34 @@ suspend fun main(args: Array<String>) {`
`4`	`4`	`// Parse CLI arguments`
`5`	`5`	`val isSharedPool = args.getOrNull(0)?.toBooleanStrictOrNull() ?: false`
`6`	`6`	`val poolSize = args.getOrNull(1)?.toIntOrNull() ?: 8`
`7`		`- val useOptimizedConfig = args.getOrNull(2)?.toBooleanStrictOrNull() ?: false`
	`7`	`+ val useKtorR2dbcConfig = args.getOrNull(2)?.toBooleanStrictOrNull() ?: false`
`8`	`8`
`9`	`9`	`val benchmarkName = buildString {`
`10`	`10`	`append("Vert.x-Web Kotlinx with Exposed R2DBC (and PostgreSQL)")`
`11`		`- if (!isSharedPool \|\| poolSize != 512 \|\| !useOptimizedConfig) {`
	`11`	`+ if (!isSharedPool \|\| poolSize != 512 \|\| !useKtorR2dbcConfig) {`
`12`	`12`	`append(" - ")`
`13`	`13`	`if (isSharedPool) {`
`14`	`14`	`append("Shared Pool Size $poolSize")`
`15`	`15`	`} else {`
`16`	`16`	`append("Separate Pool Size $poolSize")`
`17`	`17`	`}`
`18`		`- if (useOptimizedConfig) {`
`19`		`- append(" Optimized")`
	`18`	`+ if (useKtorR2dbcConfig) {`
	`19`	`+ append(" Ktor R2DBC portion config")`
`20`	`20`	`}`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`if (isSharedPool) {`
`25`	`25`	`commonRunVertxServer(`
`26`	`26`	`benchmarkName,`
`27`		`- { r2dbcConnectPool(poolSize, useOptimizedConfig) },`
	`27`	`+ { r2dbcConnectPool(poolSize, useKtorR2dbcConfig) },`
`28`	`28`	`::MainVerticle`
`29`	`29`	`)`
`30`	`30`	`} else {`
`31`	`31`	`commonRunVertxServer(`
`32`	`32`	`benchmarkName,`
`33`	`33`	`{ Unit },`
`34`		`- { MainVerticleWithSeparatePool(poolSize, useOptimizedConfig) }`
	`34`	`+ { MainVerticleWithSeparatePool(poolSize, useKtorR2dbcConfig) }`
`35`	`35`	`)`
`36`	`36`	`}`
`37`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-import database.connectionPoolOptimized`
	`1`	`+import database.connectionPoolKtorR2dbc`
`2`	`2`	`import database.connectionPoolOriginal`
`3`	`3`	`import io.r2dbc.spi.ConnectionFactory`
`4`	`4`
`@@ -7,27 +7,27 @@ suspend fun main(args: Array<String>) {`
`7`	`7`	`val isSharedPool = args.getOrNull(0)?.toBooleanStrictOrNull() ?: false`
`8`	`8`	`val poolSize = args.getOrNull(1)?.toIntOrNull()`
`9`	`9`	?: 8 // TODO `1` might produce equivalent results because there is no transaction in this portion compared to `exposed-r2dbc`.
`10`		`- val useOptimizedConfig = args.getOrNull(2)?.toBooleanStrictOrNull() ?: false`
	`10`	`+ val useKtorR2dbcConfig = args.getOrNull(2)?.toBooleanStrictOrNull() ?: false`
`11`	`11`
`12`	`12`	`val benchmarkName = buildString {`
`13`	`13`	`append("Vert.x-Web Kotlinx with R2DBC (and PostgreSQL)")`
`14`		`- if (!isSharedPool \|\| poolSize != 512 \|\| !useOptimizedConfig) {`
	`14`	`+ if (!isSharedPool \|\| poolSize != 512 \|\| !useKtorR2dbcConfig) {`
`15`	`15`	`append(" - ")`
`16`	`16`	`if (isSharedPool) {`
`17`	`17`	`append("Shared Pool Size $poolSize")`
`18`	`18`	`} else {`
`19`	`19`	`append("Separate Pool Size $poolSize")`
`20`	`20`	`}`
`21`		`- if (useOptimizedConfig) {`
`22`		`- append(" Optimized")`
	`21`	`+ if (useKtorR2dbcConfig) {`
	`22`	`+ append(" Ktor R2DBC portion config")`
`23`	`23`	`}`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`if (isSharedPool) {`
`28`	`28`	`// Shared pool: create one ConnectionPool that all verticles will share`
`29`		`- val connectionFactory: ConnectionFactory = if (useOptimizedConfig) {`
`30`		`- connectionPoolOptimized(poolSize)`
	`29`	`+ val connectionFactory: ConnectionFactory = if (useKtorR2dbcConfig) {`
	`30`	`+ connectionPoolKtorR2dbc(poolSize)`
`31`	`31`	`} else {`
`32`	`32`	`connectionPoolOriginal(poolSize)`
`33`	`33`	`}`
`@@ -42,7 +42,7 @@ suspend fun main(args: Array<String>) {`
`42`	`42`	`commonRunVertxServer(`
`43`	`43`	`benchmarkName,`
`44`	`44`	`{},`
`45`		`- { MainVerticleWithSeparatePool(poolSize, useOptimizedConfig) }`
	`45`	`+ { MainVerticleWithSeparatePool(poolSize, useKtorR2dbcConfig) }`
`46`	`46`	`)`
`47`	`47`	`}`
`48`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -56,9 +56,9 @@ class MainVerticle(private val connectionFactory: ConnectionFactory) : CommonWit`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`// Factory function for creating MainVerticle with separate connection pools`
`59`		`-fun MainVerticleWithSeparatePool(poolSize: Int, useOptimizedConfig: Boolean): MainVerticle {`
`60`		`- val connectionPool = if (useOptimizedConfig) {`
`61`		`- connectionPoolOptimized(poolSize)`
	`59`	`+fun MainVerticleWithSeparatePool(poolSize: Int, useKtorR2dbcConfig: Boolean): MainVerticle {`
	`60`	`+ val connectionPool = if (useKtorR2dbcConfig) {`
	`61`	`+ connectionPoolKtorR2dbc(poolSize)`
`62`	`62`	`} else {`
`63`	`63`	`connectionPoolOriginal(poolSize)`
`64`	`64`	`}`