Skip to content

The formatter allocates over 1,000 times its input, and the native binary spends most of its run collecting it #229

Open

Description

@abashev

What happens

Formatting allocates more than a thousand times the size of its input, and the native binary spends most of its run collecting it. 865 files from java.base of JDK 21, 15 MB of source, --replace with 21.0.2 on 10 cores:

Wall Of it in GC pauses Peak RSS
Native binary 6.9 s 5.0 s: 17 full collections for 3.05 s, 23 incremental for 1.94 s 2.4 GB
java -cp ... Main, JDK 21 6.2 s 4.3 GB

The native run's GC log adds up to at least 16.6 GB allocated, about 1,100 bytes for each byte of source. The image is built without --gc, so its serial collector stops all 20 threads for each collection, and they format on about 2 of the 10 cores (15 s of CPU in 6.9 s).

Input and output are not where it goes: reading the 865 files takes 0.04 s, and Main's reading and writing are 0.5% of the allocation, so memory-mapped files or other I/O changes cannot help.

Where it goes

Flight Recorder on the JVM run, with -XX:FlightRecorderOptions:stackdepth=2048 so that no stack was cut, 1,611 allocation samples and 469 CPU samples:

Step of FormatFileCallable.formatFile Allocation CPU
Formatter.formatSource, the layout 65.5% 56.1%
StringWrapper.wrap 16.8% 23.5%
RemoveUnusedImports 12.9% 19.8%
ImportOrderer 4.0% 0.6%
Main, reading and writing 0.5%
  • The file is parsed several times. 42% of the CPU is in javac's parser and scanner: 16% for the layout, 16% for the parse of its own that RemoveUnusedImports makes, 10% in StringWrapper, whose rounds parse again and parse before and after to compare the trees.
  • Each parse sets javac up from scratch: 18.1% of the allocation. Formatter.parseJcCompilationUnit, JavacTokens.getTokens and JavaInput.buildToks each create a new Context, and with it a SharedNameTable (NameImpl[0x8000] and byte[0x20000]), the writers of Log, and the buffers of ClassWriter (through Modules), ClassReader and even Gen, which parsing does not use. javac keeps disposed name tables for reuse (SharedNameTable.create), but nothing here calls Names.dispose().
  • The top sites otherwise: OpsBuilder.build 11.5%, the memoizing supplier of HasUniqueId.ord 4.6% plus 2.3% for its Suppliers objects, Doc.<init> 4.3%, InputOutput.makeKToIJ 3.1%, JavaOutput.append 2.7%. By class: byte[] 23.4%, char[] 8.3%, Object[] 8.1%, boxed Integer 7.2%, Guava Range 2.7%.

Proposal

In order of what each is likely to give for its work, each measured on the run above:

  1. The native image's collector: a larger young generation, another collector where GraalVM offers one for the platform, fewer threads under the serial one (Read, format and write each file on a worker thread, and keep only what the output needs #228).
  2. javac set up once per thread, or reused: call Names.dispose() after each parse so that javac hands the name table out again, and find what makes a parse create Modules, ClassWriter, ClassReader and Gen, and stop it.
  3. One parse per file: RemoveUnusedImports and StringWrapper work from the compilation unit and tokens of the formatting pass where the text did not change, as google-java-format's Cleanups reuse its parse (google/google-java-format@633ce6be, Fix the imports before the layout or after it? #224).
  4. Fewer small objects in the layout: token positions as int, not boxed Integer in Ranges, and the unique ids of Docs without a memoizing supplier for each.

Activity

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    enhancementNew feature or request

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions