1BRC in Kotlin

[GavinRay97]

This implementation isn't the fastest, but it's an interesting challenge regardless.
Results vs ebarlas, on 1/10th of the dataset (laptop doesn't have enough RAM)

ebarlas:
Elapsed time: 0.477 seconds

mine:
Elapsed time: 1.572 seconds

So it's about 1/3rd as performant 🤷

typealias StationName = String

data class Stats(var min: Double, var mean: Double, var max: Double, var count: Double) {
    override fun toString(): String {
        return "%.1f/%.1f/%.1f".format(min, mean, max)
    }

    companion object {
        fun mergeStats(a: Stats?, b: Stats): Stats {
            if (a == null) return b
            return Stats(
                min(a.min, b.min),
                (a.mean * a.count + b.mean * b.count) / (a.count + b.count),
                max(a.max, b.max),
                a.count + b.count
            )
        }
    }
}

object WeatherStatsCalculator {
    val FILE_PATH = "measurements_tenth.txt"
    val NUM_CPUS = Runtime.getRuntime().availableProcessors()

    data class FileExtent(val start: Long, val end: Long)

    fun calculate() {
        val fc = FileChannel.open(Path.of(FILE_PATH), StandardOpenOption.READ)
        val fileSize = fc.size()

        val memory = fc.map(FileChannel.MapMode.READ_ONLY, 0, fileSize, Arena.global())

        val chunkSize = fileSize / NUM_CPUS
        val fileExtents = detectFileSplits(memory, fileSize, chunkSize)

        val mappedBuffers = fileExtents.map { extent ->
            memory.asSlice(extent.start, extent.end - extent.start).asByteBuffer()
        }

        // Calculate stats for each buffer in parallel
        val stats = mappedBuffers.parallelStream()
            .map(::calculateStats).toList()
            .fold(TreeMap<StationName, Stats>()) { acc, map ->
                map.forEach { (station, stats) ->
                    acc[station] = Stats.mergeStats(acc[station], stats)
                }
                acc
            }

        println(stats)
    }

    fun detectFileSplits(buffer: MemorySegment, fileSize: Long, chunkSize: Long): List<FileExtent> {
        return buildList {
            var start = 0L
            var end = 0L
            while (start < fileSize) {
                end = min(start + chunkSize, fileSize)

                while (end < fileSize && buffer[ValueLayout.JAVA_BYTE, end].toChar() != '\n') {
                    end++
                }

                if (end <= fileSize) {
                    add(FileExtent(start, end))
                    start = end + 1
                }
            }
        }
    }

    fun calculateStats(buffer: ByteBuffer): Map<StationName, Stats> {
        val stationName = StringBuilder()
        val temperature = StringBuilder()

        val stats = mutableMapOf<StationName, Stats>()
        var isReadingStationName = true

        while (buffer.hasRemaining()) {
            val c = buffer.get().toChar()
            when {
                c == ';' -> isReadingStationName = false
                c == '\n' -> {
                    isReadingStationName = true
                    val station = stationName.toString()
                    val temp = temperature.toString().toDouble()
                    val stationStats = stats[station]
                    val newEntry = Stats(temp, temp, temp, 1.0)
                    stats[station] = if (stationStats == null) newEntry else Stats.mergeStats(stationStats, newEntry)
                    stationName.clear()
                    temperature.clear()
                }
                isReadingStationName -> stationName.append(c)
                else -> temperature.append(c)
            }
        }

        return stats
    }

}

fun main() {
    WeatherStatsCalculator.calculate()
}