Re: RFR: 8333086: Using Console.println is unnecessarily slow due to JLine initalization [v3]
On Wed, 5 Jun 2024 12:36:33 GMT, Jan Lahoda wrote: >> Consider these two programs: >> >> >> public class SystemPrint { >> public static void main(String... args) { >> System.err.println("Hello!"); >> } >> } >> >> and: >> >> public class IOPrint { >> public static void main(String... args) { >> java.io.IO.println("Hello!"); >> } >> } >> >> >> They do the same conceptual thing - write a text to the output. But, >> `IO.println` delegates to `Console.println`, which then delegates to a >> `Console` backend, and the default backend is currently based on JLine. >> >> The issues is that JLine takes a quite a long time to initialize, and in a >> program like this, JLine is not really needed - it is used to provide better >> editing experience when reading input, but there's no reading in these >> programs. >> >> For example, on my computer: >> >> $ time java -classpath /tmp SystemPrint >> Hello! >> >> real0m0,035s >> user0m0,019s >> sys 0m0,019s >> >> $ time java -classpath /tmp --enable-preview IOPrint >> Hello! >> >> real0m0,165s >> user0m0,324s >> sys 0m0,042s >> >> >> The proposal herein is to delegate to the simpler `Console` backend from >> `java.base` as long as the user only uses methods that print to output, and >> switch to the JLine delegate when other methods (typically input) is used. >> Note that while technically `writer()` is a method doing output, it will >> force JLine initialization to avoid possible problems if the client caches >> the writer and uses it after switching the delegates. >> >> With this patch, I can get timing like this: >> >> $ time java --enable-preview -classpath /tmp/ IOPrint >> Hello! >> >> real0m0,051s >> user0m0,038s >> sys 0m0,020s >> >> >> which seems much more acceptable. >> >> There is also #19467, which may reduce the time further. >> >> A future work might focus on making JLine initialize faster, but avoiding >> JLine initialization in case where we don't need it seems like a good step >> to me in any case. > > Jan Lahoda has updated the pull request incrementally with one additional > commit since the last revision: > > Correctly reflecting review feedback LGTM. Thanks for the changes. - Marked as reviewed by naoto (Reviewer). PR Review: https://git.openjdk.org/jdk/pull/19479#pullrequestreview-2099801902
Re: RFR: 8333086: Using Console.println is unnecessarily slow due to JLine initalization [v3]
> Consider these two programs: > > > public class SystemPrint { > public static void main(String... args) { > System.err.println("Hello!"); > } > } > > and: > > public class IOPrint { > public static void main(String... args) { > java.io.IO.println("Hello!"); > } > } > > > They do the same conceptual thing - write a text to the output. But, > `IO.println` delegates to `Console.println`, which then delegates to a > `Console` backend, and the default backend is currently based on JLine. > > The issues is that JLine takes a quite a long time to initialize, and in a > program like this, JLine is not really needed - it is used to provide better > editing experience when reading input, but there's no reading in these > programs. > > For example, on my computer: > > $ time java -classpath /tmp SystemPrint > Hello! > > real0m0,035s > user0m0,019s > sys 0m0,019s > > $ time java -classpath /tmp --enable-preview IOPrint > Hello! > > real0m0,165s > user0m0,324s > sys 0m0,042s > > > The proposal herein is to delegate to the simpler `Console` backend from > `java.base` as long as the user only uses methods that print to output, and > switch to the JLine delegate when other methods (typically input) is used. > Note that while technically `writer()` is a method doing output, it will > force JLine initialization to avoid possible problems if the client caches > the writer and uses it after switching the delegates. > > With this patch, I can get timing like this: > > $ time java --enable-preview -classpath /tmp/ IOPrint > Hello! > > real0m0,051s > user0m0,038s > sys 0m0,020s > > > which seems much more acceptable. > > There is also #19467, which may reduce the time further. > > A future work might focus on making JLine initialize faster, but avoiding > JLine initialization in case where we don't need it seems like a good step to > me in any case. Jan Lahoda has updated the pull request incrementally with one additional commit since the last revision: Correctly reflecting review feedback - Changes: - all: https://git.openjdk.org/jdk/pull/19479/files - new: https://git.openjdk.org/jdk/pull/19479/files/7a0c448f..f3259793 Webrevs: - full: https://webrevs.openjdk.org/?repo=jdk=19479=02 - incr: https://webrevs.openjdk.org/?repo=jdk=19479=01-02 Stats: 2 lines in 1 file changed: 1 ins; 0 del; 1 mod Patch: https://git.openjdk.org/jdk/pull/19479.diff Fetch: git fetch https://git.openjdk.org/jdk.git pull/19479/head:pull/19479 PR: https://git.openjdk.org/jdk/pull/19479
Re: RFR: 8333086: Using Console.println is unnecessarily slow due to JLine initalization [v2]
> Consider these two programs: > > > public class SystemPrint { > public static void main(String... args) { > System.err.println("Hello!"); > } > } > > and: > > public class IOPrint { > public static void main(String... args) { > java.io.IO.println("Hello!"); > } > } > > > They do the same conceptual thing - write a text to the output. But, > `IO.println` delegates to `Console.println`, which then delegates to a > `Console` backend, and the default backend is currently based on JLine. > > The issues is that JLine takes a quite a long time to initialize, and in a > program like this, JLine is not really needed - it is used to provide better > editing experience when reading input, but there's no reading in these > programs. > > For example, on my computer: > > $ time java -classpath /tmp SystemPrint > Hello! > > real0m0,035s > user0m0,019s > sys 0m0,019s > > $ time java -classpath /tmp --enable-preview IOPrint > Hello! > > real0m0,165s > user0m0,324s > sys 0m0,042s > > > The proposal herein is to delegate to the simpler `Console` backend from > `java.base` as long as the user only uses methods that print to output, and > switch to the JLine delegate when other methods (typically input) is used. > Note that while technically `writer()` is a method doing output, it will > force JLine initialization to avoid possible problems if the client caches > the writer and uses it after switching the delegates. > > With this patch, I can get timing like this: > > $ time java --enable-preview -classpath /tmp/ IOPrint > Hello! > > real0m0,051s > user0m0,038s > sys 0m0,020s > > > which seems much more acceptable. > > There is also #19467, which may reduce the time further. > > A future work might focus on making JLine initialize faster, but avoiding > JLine initialization in case where we don't need it seems like a good step to > me in any case. Jan Lahoda has updated the pull request incrementally with one additional commit since the last revision: Reflecting review feedback - explicitly selecting the jdk.internal.le provider in the test. - Changes: - all: https://git.openjdk.org/jdk/pull/19479/files - new: https://git.openjdk.org/jdk/pull/19479/files/9886732e..7a0c448f Webrevs: - full: https://webrevs.openjdk.org/?repo=jdk=19479=01 - incr: https://webrevs.openjdk.org/?repo=jdk=19479=00-01 Stats: 1 line in 1 file changed: 0 ins; 0 del; 1 mod Patch: https://git.openjdk.org/jdk/pull/19479.diff Fetch: git fetch https://git.openjdk.org/jdk.git pull/19479/head:pull/19479 PR: https://git.openjdk.org/jdk/pull/19479
Re: RFR: 8333086: Using Console.println is unnecessarily slow due to JLine initalization
On Thu, 30 May 2024 13:50:33 GMT, Jan Lahoda wrote: > Consider these two programs: > > > public class SystemPrint { > public static void main(String... args) { > System.err.println("Hello!"); > } > } > > and: > > public class IOPrint { > public static void main(String... args) { > java.io.IO.println("Hello!"); > } > } > > > They do the same conceptual thing - write a text to the output. But, > `IO.println` delegates to `Console.println`, which then delegates to a > `Console` backend, and the default backend is currently based on JLine. > > The issues is that JLine takes a quite a long time to initialize, and in a > program like this, JLine is not really needed - it is used to provide better > editing experience when reading input, but there's no reading in these > programs. > > For example, on my computer: > > $ time java -classpath /tmp SystemPrint > Hello! > > real0m0,035s > user0m0,019s > sys 0m0,019s > > $ time java -classpath /tmp --enable-preview IOPrint > Hello! > > real0m0,165s > user0m0,324s > sys 0m0,042s > > > The proposal herein is to delegate to the simpler `Console` backend from > `java.base` as long as the user only uses methods that print to output, and > switch to the JLine delegate when other methods (typically input) is used. > Note that while technically `writer()` is a method doing output, it will > force JLine initialization to avoid possible problems if the client caches > the writer and uses it after switching the delegates. > > With this patch, I can get timing like this: > > $ time java --enable-preview -classpath /tmp/ IOPrint > Hello! > > real0m0,051s > user0m0,038s > sys 0m0,020s > > > which seems much more acceptable. > > There is also #19467, which may reduce the time further. > > A future work might focus on making JLine initialize faster, but avoiding > JLine initialization in case where we don't need it seems like a good step to > me in any case. Looks good with a minor nit. test/jdk/jdk/internal/jline/LazyJdkConsoleProvider.java line 74: > 72: ProcessBuilder builder = > 73: > ProcessTools.createTestJavaProcessBuilder("--enable-preview", > 74: > "-verbose:class", Better to explicitly specify `-Djdk.console=jdk.internal.le` - PR Review: https://git.openjdk.org/jdk/pull/19479#pullrequestreview-2096855434 PR Review Comment: https://git.openjdk.org/jdk/pull/19479#discussion_r1626281874
Re: RFR: 8333086: Using Console.println is unnecessarily slow due to JLine initalization
On Thu, 30 May 2024 13:50:33 GMT, Jan Lahoda wrote: > Consider these two programs: > > > public class SystemPrint { > public static void main(String... args) { > System.err.println("Hello!"); > } > } > > and: > > public class IOPrint { > public static void main(String... args) { > java.io.IO.println("Hello!"); > } > } > > > They do the same conceptual thing - write a text to the output. But, > `IO.println` delegates to `Console.println`, which then delegates to a > `Console` backend, and the default backend is currently based on JLine. > > The issues is that JLine takes a quite a long time to initialize, and in a > program like this, JLine is not really needed - it is used to provide better > editing experience when reading input, but there's no reading in these > programs. > > For example, on my computer: > > $ time java -classpath /tmp SystemPrint > Hello! > > real0m0,035s > user0m0,019s > sys 0m0,019s > > $ time java -classpath /tmp --enable-preview IOPrint > Hello! > > real0m0,165s > user0m0,324s > sys 0m0,042s > > > The proposal herein is to delegate to the simpler `Console` backend from > `java.base` as long as the user only uses methods that print to output, and > switch to the JLine delegate when other methods (typically input) is used. > Note that while technically `writer()` is a method doing output, it will > force JLine initialization to avoid possible problems if the client caches > the writer and uses it after switching the delegates. > > With this patch, I can get timing like this: > > $ time java --enable-preview -classpath /tmp/ IOPrint > Hello! > > real0m0,051s > user0m0,038s > sys 0m0,020s > > > which seems much more acceptable. > > There is also #19467, which may reduce the time further. > > A future work might focus on making JLine initialize faster, but avoiding > JLine initialization in case where we don't need it seems like a good step to > me in any case. It looks like a legit performance trick. - Marked as reviewed by asotona (Reviewer). PR Review: https://git.openjdk.org/jdk/pull/19479#pullrequestreview-2096720909
RFR: 8333086: Using Console.println is unnecessarily slow due to JLine initalization
Consider these two programs: public class SystemPrint { public static void main(String... args) { System.err.println("Hello!"); } } and: public class IOPrint { public static void main(String... args) { java.io.IO.println("Hello!"); } } They do the same conceptual thing - write a text to the output. But, `IO.println` delegates to `Console.println`, which then delegates to a `Console` backend, and the default backend is currently based on JLine. The issues is that JLine takes a quite a long time to initialize, and in a program like this, JLine is not really needed - it is used to provide better editing experience when reading input, but there's no reading in these programs. For example, on my computer: $ time java -classpath /tmp SystemPrint Hello! real0m0,035s user0m0,019s sys 0m0,019s $ time java -classpath /tmp --enable-preview IOPrint Hello! real0m0,165s user0m0,324s sys 0m0,042s The proposal herein is to delegate to the simpler `Console` backend from `java.base` as long as the user only uses methods that print to output, and switch to the JLine delegate when other methods (typically input) is used. Note that while technically `writer()` is a method doing output, it will force JLine initialization to avoid possible problems if the client caches the writer and uses it after switching the delegates. With this patch, I can get timing like this: $ time java --enable-preview -classpath /tmp/ IOPrint Hello! real0m0,051s user0m0,038s sys 0m0,020s which seems much more acceptable. There is also #19467, which may reduce the time further. A future work might focus on making JLine initialize faster, but avoiding JLine initialization in case where we don't need it seems like a good step to me in any case. - Commit messages: - Cleanup, addint test. - Using println correctly, flushing the java.base delegate before switching to JLine. - Force Terminal when writer is requested. - Attempting to speedup start by delaying initialization of JLine until really necessary. Changes: https://git.openjdk.org/jdk/pull/19479/files Webrev: https://webrevs.openjdk.org/?repo=jdk=19479=00 Issue: https://bugs.openjdk.org/browse/JDK-8333086 Stats: 225 lines in 2 files changed: 212 ins; 1 del; 12 mod Patch: https://git.openjdk.org/jdk/pull/19479.diff Fetch: git fetch https://git.openjdk.org/jdk.git pull/19479/head:pull/19479 PR: https://git.openjdk.org/jdk/pull/19479