Quarkus native executable build: high memory consumption

Question

I'm building a Quarkus native executable with a multi-stage Docker build as described in Quarkus - Building a Native Executable

My project just includes the Hello World-Example with some added ORM-functionality (so not really a lot of dependencies). The build works fine, but my problem is, that it consumes a lot of memory during build time. That means up to 6 GiB. Build time is also very long in my opinion (~4-6 minutes in total).

The problem starts when I'm building on our CI/CD-infrastructure. We don't have that much memory there and so the build fails with Error: Image build request failed with exit status 137.

Am I doing something wrong or is this just the normal behaviour? Is there a possibility to reduce at least the memory consumption?

The memory consumption is a result of GraalVM Native Image generation, it's unrelated to Quarkus. We're aware it usually takes around 4Gb of RAM to perform a native image build, and it usually takes 2-3 minutes, depending on the CPU — Ken, Jul 23 '19 at 17:57
So there is no possibility to limit resources used by GraalVM? Time doesn't really matter in this case, but memory does. — Ben, Jul 24 '19 at 04:43
You can use the -J to pass the flag to the jvm that is running the image generator so you should be able to limit the memory with something like -Xmx5G (be aware that it may significantly slows down the image generation process). In quarkus you can set it through additionalBuildArgs configuration option on the maven plugin — Luca Burgazzoli, Jul 24 '19 at 06:20
It works, but as you said, it build time is increased. I'm now at 10 minutes with `-Xmx2G`. — Ben, Jul 24 '19 at 14:32

score 7 · Accepted Answer · answered Jul 24 '19 at 14:37

Thanks to Ken and Luca Burgazzoli! So, it is normal for GraalVM to use >4GiB of RAM and to take more than 3 minutes.

One can limit memory consumption by specifiying -J-Xmx2G as an additionalBuildArgs-param for the quarkus-maven-plugin. But this may increase build time.

score 5 · Answer 2 · answered Sep 28 '19 at 04:48

@ben answer is correct but maybe it is useful to be more precise. You have to edit the pom.xml in the getting-started dir and edit the native profile and adding <additionalBuildArgs>-J-Xmx2G</additionalBuildArgs> like this:

  <profile>
        <id>native</id>
        <activation>
            <property>
                <name>native</name>
            </property>
        </activation>
        <build>
            <plugins>
                <plugin>
                    <groupId>io.quarkus</groupId>
                    <artifactId>quarkus-maven-plugin</artifactId>
                    <version>${quarkus.version}</version>
                    <executions>
                        <execution>
                            <goals>
                                <goal>native-image</goal>
                            </goals>
                            <configuration>
                                <enableHttpUrlHandler>true</enableHttpUrlHandler>
                <additionalBuildArgs>-J-Xmx2G</additionalBuildArgs>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <artifactId>maven-failsafe-plugin</artifactId>
                     ...
                </plugin>
            </plugins>
        </build>
    </profile>

sunix · Answer 3 · 2020-11-05T13:35:54.420

3

Now, you can limit memory usage from Quarkus:

In your src/main/resources/application.properties file, just set:

quarkus.native.native-image-xmx=2G

Or just pass this option to maven:

mvn package -Dnative -Dquarkus.native.native-image-xmx=2G

edited Nov 05 '20 at 13:35

answered Nov 05 '20 at 13:15

sunix

323
1
3
8

score 2 · Answer 4 · answered Feb 24 '20 at 13:00

If you are using gradle, edit the build.gradle like this:

.
.
.

compileJava {
    options.compilerArgs << '-parameters'
}

buildNative {
   additionalBuildArgs = [
           '-J-Xmx2G'
   ]
}

So you can limit the memory usage when building with gradle.

score 1 · Answer 5 · answered May 17 '20 at 00:02

With camel quarkus example using maven, I configured as follows to make it work:

<profiles>
    <profile>
        <id>native</id>
        <activation>
            <property>
                <name>native</name>
            </property>
        </activation>
        <properties>
            <quarkus.package.type>native</quarkus.package.type>
            <quarkus.native.additional-build-args>-J-Xmx5G</quarkus.native.additional-build-args>
        </properties>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-failsafe-plugin</artifactId>
                    <executions>
                        <execution>
                            <goals>
                                <goal>integration-test</goal>
                                <goal>verify</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>

Using the option <quarkus.native.additional-build-args>-J-Xmx5G</quarkus.native.additional-build-args>

Quarkus native executable build: high memory consumption

5 Answers5