Benchmark Kotlin (JVM) write to File

Code

package com.glassthought.sandbox

import com.asgard.testTools.benchmarker.BenchMarkerJVM
import java.io.File
import java.io.FileOutputStream

/**
 * Benchmark comparing file write performance WITH and WITHOUT disk sync.
 *
 * CRITICAL DISTINCTION:
 * - WITHOUT sync (File.writeText): Writes only to OS cache buffer
 *   PRO: Order of magnitude faster (e.g., 0.05ms vs 5ms)
 *   CON: Data NOT guaranteed to survive system crash after writeText completes
 *
 * - WITH sync (fd.sync()): Forces write to physical disk
 *   PRO: Data guaranteed to survive power loss/system crash
 *   CON: Much slower due to physical I/O
 */
suspend fun main(args: Array<String>) {
  // Compare with and without sync to see the performance difference
  println("\n=== WITH DISK SYNC (guaranteed persistence) ===")
  benchmarkFileWrite(500, syncToDisk = true)
  benchmarkFileWrite(1000, syncToDisk = true)
  benchmarkFileWrite(2000, syncToDisk = true)
  benchmarkFileWrite(10000, syncToDisk = true)

  println("=== WITHOUT DISK SYNC (OS buffer only) ===")
  benchmarkFileWrite(500, syncToDisk = false)
  benchmarkFileWrite(1000, syncToDisk = false)
  benchmarkFileWrite(2000, syncToDisk = false)
  benchmarkFileWrite(10000, syncToDisk = false)
}

fun getRandomChar(): String {
  return ('a'..'z').random().toString()
}

private suspend fun benchmarkFileWrite(howManyChars: Int, syncToDisk: Boolean = true) {
  val string = (1..howManyChars).joinToString("") { getRandomChar() }
  val file = File("/tmp/output-file")

  val description = if (syncToDisk) {
    "Write [${string.length}] chars WITH disk sync (guaranteed persistence)"
  } else {
    "Write [${string.length}] chars WITHOUT sync (OS buffer only)"
  }

  val result = BenchMarkerJVM.benchMark({
    if (syncToDisk) {
      // WITH SYNC: Data is guaranteed to survive system crash
      // CON: Much slower (e.g., 5ms)
      FileOutputStream(file).use { fos ->
        fos.write(string.toByteArray(Charsets.UTF_8))
        fos.flush() // Flush to OS buffer
        fos.fd.sync() // Force sync to physical disk - GUARANTEES persistence
      }
    } else {
      // WITHOUT SYNC: Only writes to OS cache buffer
      // PRO: Order of magnitude faster (e.g., 0.05ms instead of 5ms)
      // CON: Data is NOT guaranteed to survive a system crash after writeText completes
      file.writeText(string, Charsets.UTF_8)
    }
  }, 1000, description = description)

  result.printFormattedTable()
}

Command to reproduce:

gt.sandbox.checkout.commit b7ad25225b70a37866b9 \
&& cd "${GT_SANDBOX_REPO}" \
&& cmd.run.announce "./gradlew run --quiet"

Recorded output of command:

=== WITH DISK SYNC (guaranteed persistence) ===

Benchmark: Write [500] chars WITH disk sync (guaranteed persistence)

Benchmark: Write [1000] chars WITH disk sync (guaranteed persistence)

Benchmark: Write [2000] chars WITH disk sync (guaranteed persistence)

Benchmark: Write [10000] chars WITH disk sync (guaranteed persistence)

=== WITHOUT DISK SYNC (OS buffer only) ===

Benchmark: Write [500] chars WITHOUT sync (OS buffer only)

Benchmark: Write [1000] chars WITHOUT sync (OS buffer only)

Benchmark: Write [2000] chars WITHOUT sync (OS buffer only)

Benchmark: Write [10000] chars WITHOUT sync (OS buffer only)

Note if we do not explicitly sync to disk with code like

    File("/tmp/output-file").writeText(string, Charsets.UTF_8)

We will write to OS cache buffer.

• PRO: Performance will look order of magnitude faster (eg. from 5millis to 1/20th millis).
• CON: Data is NOT guaranteed to survive a system crash, after writeText completes.