Quarkus : modernisation des applications à travers l'exemple de helloworld du JBoss EAP Quickstart (suite)

Bonjour à tous, voici le cinquième article de notre série sur Quarkus ! (Au fait, regardez notre webinaire «C'est Quarkus – un framework Java natif de Kubernetes». Nous allons montrer comment commencer «de zéro» ou migrer des solutions existantes)

Dans dans le précédent article nous avons examiné la modernisation des applications Java à l'aide des technologies supportées par Quarkus (CDI et Servlet 3) à travers l'exemple du programme helloworld du dépôt Red Hat JBoss Enterprise Application Platform (JBoss EAP) Quickstart. Aujourd'hui, nous allons continuer sur la thématique de la modernisation et discuter de la question de la consommation de mémoire.

La mesure de performance est une base fondamentale de pratiquement toute modernisation, et les rapports d'utilisation de la mémoire sont une partie importante du processus d'analyse de performance. Aujourd'hui, nous aborderons les outils de mesure appropriés que vous pouvez utiliser pour évaluer quantitativement les améliorations résultant de la modernisation des applications Java.

Les détails concernant la mesure de l'utilisation de la mémoire peuvent être trouvés dans le guide Quarkus intitulé Measuring Performance—How do we measure memory usage?

Et ci-dessous, nous allons simplement montrer comment comparer les données d'utilisation de la mémoire entre trois types d'applications différentes (JBoss EAP, JAR package et executable), en collectant ces données sous Linux à l'aide des utilitaires pmap et ps.

JBoss EAP

Nous lançons une instance de l'application JBoss EAP (voir la section «Déployer helloworld» dans dans le précédent article) puis nous regardons son identifiant de processus PID (dans notre exemple, c'est 7268) à l'aide de la commande suivante :

$ pgrep -lf jboss
7268 java

Remarque. L'option –a permet d'extraire la ligne de commande complète (c'est-à-dire : $ pgrep -af jboss).

Maintenant, utilisons le PID 7268 dans les commandes ps et pmap.

Voici comment :

$ ps -o pid,rss,command -p 7268
PID RSS COMMAND 
7268 665348 java -D[Standalone] -server -verbose:gc -Xloggc:/home/mrizzi/Tools/jboss-eap-7.2.0/jboss-eap-7.2/standalone/log/gc.log -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=5 -XX:GCLogFileSize=3M -XX:-TraceClassUnloading -Xms1303m -Xmx1303m -XX:MetaspaceSize=96M -XX:MaxMetaspaceSize=256m -Djava.net.preferI

Et voici ainsi :

$ pmap -x 7268
7268:   java -D[Standalone] -server -verbose:gc -Xloggc:/home/mrizzi/Tools/jboss-eap-7.2.0/jboss-eap-7.2/standalone/log/gc.log -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=5 -XX:GCLogFileSize=3M -XX:-TraceClassUnloading -Xms1303m -Xmx1303m -XX:MetaspaceSize=96M -XX:MaxMetaspaceSize=256m -Djava.net.preferIPv4Stack=true -Djboss.modules.system.pkgs=org.jboss.byteman -Djava.awt.headless=true -Dorg.jboss.boot.log.file=/home/mrizzi/Tools/jboss-eap-7.2.0/jboss-eap-7.2/standa
Address           Kbytes     RSS   Dirty Mode  Mapping
00000000ae800000 1348608  435704  435704 rw---   [ anon ]
0000000100d00000 1035264       0       0 -----   [ anon ]
000055e4d2c2f000       4       4       0 r---- java
000055e4d2c30000       4       4       0 r-x-- java
000055e4d2c31000       4       0       0 r---- java
000055e4d2c32000       4       4       4 r---- java
000055e4d2c33000       4       4       4 rw--- java
[...]
ffffffffff600000       4       0       0 r-x--   [ anon ]
---------------- ------- ------- -------
total kB         3263224  672772  643024

Nous observons la valeur RSS et constatons que JBoss EAP consomme environ 650 Mo de mémoire.

Fichier JAR

Exécutons l'application JAR (voir la section « Exécuter helloworld empaqueté dans JAR » dans dans le précédent article):

$ java -jar ./target/helloworld-<version>-runner.jar

Nous vérifions à nouveau le PID à l'aide de la commande pgrep (nous utilisons cette fois l'option -a décrite ci-dessus) :

$ pgrep -af helloworld
6408 java -jar ./target/helloworld-<version>-runner.jar

Nous exécutons ps et pmap pour mesurer l'utilisation de la mémoire, mais maintenant pour le processus 6408.

Voici comment :

$ ps -o pid,rss,command -p 6408
  PID   RSS COMMAND
 6408 125732 java -jar ./target/helloworld-quarkus-runner.jar

Et voici ainsi :

$ pmap -x 6408
6408:   java -jar ./target/helloworld-quarkus-runner.jar
Address           Kbytes     RSS   Dirty Mode  Mapping
00000005d3200000  337408       0       0 rw---   [ anon ]
00000005e7b80000 5046272       0       0 -----   [ anon ]
000000071bb80000  168448   57576   57576 rw---   [ anon ]
0000000726000000 2523136       0       0 -----   [ anon ]
00000007c0000000    2176    2088    2088 rw---   [ anon ]
00000007c0220000 1046400       0       0 -----   [ anon ]
00005645b85d6000       4       4       0 r---- java
00005645b85d7000       4       4       0 r-x-- java
00005645b85d8000       4       0       0 r---- java
00005645b85d9000       4       4       4 r---- java
00005645b85da000       4       4       4 rw--- java
[...]
ffffffffff600000       4       0       0 r-x--   [ anon ]
---------------- ------- ------- -------
total kB         12421844  133784  115692

Nous observons à nouveau le RSS et constatons que le paquet JAR consomme environ 130 Mo.

Fichier exécutable

Nous exécutons le natif (voir la section « Exécuter le fichier exécutable natif helloworld » dans dans le précédent article):

$ ./target/helloworld-<version>-runner

Nous vérifions à nouveau son PID :

$ pgrep -af helloworld
6948 ./target/helloworld-<version>-runner

Et ensuite, nous utilisons l'identifiant de processus obtenu (6948) dans les commandes ps et pmap.

Voici comment :

$ ps -o pid,rss,command -p 6948
  PID   RSS COMMAND
 6948 19084 .\/target\/helloworld-quarkus-runner
Et voilà:
$ pmap -x 6948
6948:   .\/target\/helloworld-quarkus-runner
Adresse           Kbytes     RSS   Sale  Mode  Mapping
0000000000400000      12      12       0 r---- helloworld-quarkus-runner
0000000000403000   10736    8368       0 r-x-- helloworld-quarkus-runner
0000000000e7f000    7812    6144       0 r---- helloworld-quarkus-runner
0000000001620000    2024    1448     308 rw--- helloworld-quarkus-runner
000000000181a000       4       4       4 r---- helloworld-quarkus-runner
000000000181b000      16      16      12 rw--- helloworld-quarkus-runner
0000000001e10000    1740     156     156 rw---   [ anon ]
[...]
ffffffffff600000       4       0       0 r-x--   [ anon ]
---------------- ------- ------- -------
total kB         1456800   20592    2684

Nous regardons les RSS et voyons que le fichier exécutable utilise environ 20 Mo de mémoire.

Comparons l'utilisation de la mémoire

Ainsi, nous avons les chiffres suivants concernant l'utilisation de la mémoire :

• JBoss EAP – 650 Mo.
• Paquet JAR – 130 Mo.
• Fichier exécutable – 20 Mo.

Il est évident que le fichier exécutable utilise beaucoup moins de mémoire.

Récapitulons les post 4 et 5

Dans ce post et le précédent, nous avons examiné la modernisation des applications Java en utilisant des technologies prises en charge par Quarkus (CDI et Servlet 3), ainsi que différentes manières de développer, compiler et exécuter de telles applications. Nous avons montré comment collecter des données sur l'utilisation de la mémoire pour évaluer les améliorations obtenues grâce à cette modernisation. Ces articles aident à comprendre comment fonctionne Quarkus et en quoi cela est bénéfique, que ce soit pour le simple programme helloworld de nos exemples ou pour des applications plus complexes du monde réel.

Nous reviendrons dans deux semaines avec le post final sur Quarkus – à bientôt !

Dans notre post final, nous montrerons comment combiner AMQ Online et Quarkus pour construire un système moderne de messagerie basé sur OpenShift en utilisant deux nouvelles technologies liées à la gestion des messages. Lisez à le lien.

Source : habr.com