Hi, can I please have a review for the following simple performance enhancement:
http://cr.openjdk.java.net/~simonis/webrevs/2020/8242848/ https://bugs.openjdk.java.net/browse/JDK-8242864 InflaterOutputStream has an internal buffer which is used for the inflated data. This buffer can be configured to a custom size (the default is 512 bytes) by using the specialized "InflaterOutputStream(OutputStream out, Inflater infl, int bufLen)" constructor. A bigger buffer, results in fewer native calls to "write()" on the associated OutputStream and better overall performance. Unfortunately "InflaterOutputStream.write(byte[] b, int off, int len)" unnecessarily chunks its own byte input buffer "b" into pieces of maximum 512 bytes before feeding them to the underlying Inflater. This unnecessarily increases the number of native calls to Inflater.inflate() and limits the benefit of the configurable internal buffer to a size of ~(512 * compression-ratio) bytes. Instead, we could easily pass the complete input buffer "b" as input to the underlying Inflater. This simplifies the code and results in up to ~25% performance improvements for bigger internal buffers (see the JMH benchmark attached to the bug). Regarding the implementation, I initially wanted to completely remove the "for (;;)" loop after removing the chunking of the input buffer. But I think it is still necessary, because an InflaterOutputStream can be created with a custom Inflater which already has some input data. In that case, the Inflater will first consume its initial input data in the first "for" loop iteration while "write()"s input buffer "b" will only be consumed in the second "for" loop iteration. While doing this change, I've also realized that all the streams in java.util.zip (i.e. DeflaterInputStream, GZIPInputStream, GZIPOutputStream, InflaterInputStream, DeflaterOutputStream) use an internal byte buffer of 512 bytes by default. Looking at the benchmark attached to JDK-8242864, I think that increasing this default to a bigger size (e.g. 4096 bytes) will considerably speed up (up to 50%) read and write operations on these streams when they are created with the default buffer size. I think the value "512" is a legacy of old times when memory was more precious :) so I've opened "JDK-8242864: Increase the default, internal buffer size of the Streams in java.util.zip" to track that as as separate issue. Do you think it makes sense to increase that default value? Thank you and best regards, Volker PS: do you think it makes sense to contribute the benchmark attached to JDK-8242864 to the code-tools/mh-jdk-microbenchmarks [1] project? [1] http://openjdk.java.net/projects/code-tools/jmh-jdk-microbenchmarks/
