Merge branch 'topic/lkql_jit/upgrade_graalvm_version' into 'master'

Upgrade the GraalVM version to 24

Closes #451

See merge request eng/libadalang/langkit-query-language!524

Author: HugoGGuerrier

Makefile

@@ -61,7 +61,7 @@ build/bin/liblkqllang_parse: lkql/lkql.lkt
 test:
 	testsuite/testsuite.py -Edtmp
 
-clean: clean_lkql clean_lkql_jit clean_lkql_checker
+clean: clean_lkql_jit clean_lkql_checker clean_lkql
 
 clean_lkql:
 	rm lkql/build -rf
@@ -75,11 +75,11 @@ clean_lkql_checker:
 
 build_lkql_jit: lkql
 	$(MAVEN) -f lkql/build/java/ install
-	$(MAVEN) -f lkql_jit/ clean install $(MAVEN_ARGS)
+	$(MAVEN) -f lkql_jit/ clean package $(MAVEN_ARGS)
 
 build_lkql_native_jit: lkql
 	$(MAVEN) -f lkql/build/java/ install
-	$(MAVEN) -f lkql_jit/ clean install -P native,$(BUILD_MODE) $(MAVEN_ARGS)
+	$(MAVEN) -f lkql_jit/ clean package -P native,$(BUILD_MODE) $(MAVEN_ARGS)
 
 .PHONY: lkql_checker
 

lkql_jit/.gitignore

@@ -13,33 +13,9 @@
 # Ignore the target of the LKQL JIT project
 target
 
-# Ignore from the component module
-component/lkql_jit_component
-component/target
-component/lkql_jit_component.jar
-
 # Ignore from the language module
-language/target
 language/.apt_generated
 language/.apt_generated_tests
 
-# Ignore from the launcher module
-launcher/target
-
-# Ignore from the checker module
-checker/target
-
-# Ignore from the gnatcheck_worker module
-gnatcheck_worker/target
-
-# Ignore from the native module
-native/target
-native/bin
-native/lib
-native/reports
-native/sources
-
 # Test and log files
-my_working_dir
-language/src/test/java/TestRun.java
 *.log

lkql_jit/README.md

@@ -6,8 +6,8 @@ The JIT compiler for the LKQL language.
 Dependencies
 ------------
 
-* [GraalVM](https://www.graalvm.org/) : The high performance JVM
-* [Maven](https://maven.apache.org/) : Java project manager
+* [GraalVM](https://www.graalvm.org/) : The high performance JVM (version 24.2.1)
+* [Maven](https://maven.apache.org/) : Java building tool
 * [Python3](https://www.python.org/) : The language (3.9 or later)
 * [Langkit](https://github.com/AdaCore/langkit) : The language front-end creation framework
 * [Libadalang](https://github.com/AdaCore/libadalang)
@@ -17,29 +17,23 @@ How to build and run
 --------------------
 
 First, you need to ensure that the `mvn` command is accessible and fairly recent (at least 3.8.5).
-
-Then, make sure you have an accessible Python3 installation. Python 3.9 or later.
-
-You also need to install GraalVM's `native-image` utility, which can be done
-running `gu install native-image` (where `gu` is in the `bin` directory of the GraalVM
-installation).
-
-Also make sure that your GraalVM installation is for Java 17, as Java 19 is not supported for now.
-For information, the tested version of GraalVM is graalvm-ce-java17-22.3.1.
+Then, make sure you have an accessible Python3 installation, version 3.9 or later.
+Also make sure that your GraalVM installation is in the 24.2.1 version.
+Finally, make sure that `native-image` tool is available in your environment.
 
 ### 1) Install Langkit and make sure it is usable
 
 ```sh
 $[langkit]> pip3 install -r requirement-pypi.txt
 $[langkit]> ./manage.py make
-$[langkit]> eval `./manage.py setenv`
+$[langkit]> eval `./manage.py printenv`
 $[langkit]> export PATH="/path/to/langkit/scripts:$PATH"
 ```
 
-If you get a Python error about the langkit library, add the langkit directory to your `PYTHONPATH`
+If you get a Python error about the Langkit library, add the Langkit directory to your `PYTHONPATH`
 environment variable.
 
-*Note: If for some reason you are not running `./manage.py setenv`, make sure that the
+*Note: If for some reason you are not running `./manage.py printenv`, make sure that the
 `sigsegv_handler` library is reachable from your `LD_LIBRARY_PATH`.*
 
 Install the Java LangkitSupport library:
@@ -52,7 +46,7 @@ $[langkit]> mvn -f langkit/java_support install
 
 ```sh
 $[libadalang]> lkm make --enable-java
-$[libadalang]> eval `lkm setenv`
+$[libadalang]> eval `lkm printenv`
 ```
 
 Make sure the Java bindings are installed locally
@@ -65,7 +59,7 @@ $[libadalang]> mvn -f build/java install
 
 ```sh
 $[langkit-query-language/lkql]> lkm make --enable-java
-$[langkit-query-language/lkql]> eval `lkm setenv`
+$[langkit-query-language/lkql]> eval `lkm printenv`
 ```
 
 As for Libadalang, make sure Java bindings are installed
@@ -82,99 +76,59 @@ $[langkit-query-language/lkql]> mvn -f build/java install
 ### 5) Build and run LKQL_JIT
 
 ```sh
-$[langkit-query-language/lkql_jit]> mvn clean install
+$[langkit-query-language/lkql_jit]> mvn clean package
 ```
 
-You can now access the LKQL JIT launcher using the `lkql.py` Python script that has been installed
-in the `languages/lkql/bin` directory of your GraalVM installation.
+You can now access LKQL JIT by running the `langkit-query-language/lkql_jit/standalone/target/lkql.py`
+script.
 
-This script will launch LKQL JIT with the current accessible Java installation (`java -jar
-lkql_cli.jar ...`) so you have to run it in a valid environment.
+This script will launch LKQL JIT with the current accessible Java installation (`java -jar ...`)
+so you have to run it in a valid environment.
 
 If you want to build LKQL JIT as a native executable, you can use the `native` Maven profile:
 
 ```sh
-$[langkit-query-language/lkql_jit]> mvn clean install -P native
+$[langkit-query-language/lkql_jit]> mvn clean package -P native
 ```
 
-Then the `lkql` executable will be available under the `langkit-query-language/lkql_jit/native/bin`
-directory and will be installed to your local GraalVM guest languages folder
-(`$GRAAL_HOME/languages/lkql/bin`).
+Then the `lkql` executable will be available under the `langkit-query-language/lkql_jit/standalone/target`
+directory.
 
 ### 6) Running the code formatter
 
-LKQL JIT project uses the `google-java-format` as code formatter. It is run every time you call
-the `compile` Maven phase and will raise an error if there is a style violation in the LKQL JIT
-source code. To automatically format all Java files you can run the following command:
+LKQL JIT project uses `prettier-java` as code formatter, and the `spotless` Maven plugin is configured
+to run it on demand. You can run the following command to format all Java sources:
 
 ```sh
-$[langkit-query-language/lkql_jit] mvn spotless:apply
+$[langkit-query-language/lkql_jit]> mvn spotless:apply
+```
+
+However, running it is very prone to error, thus you can install pre-commit
+hooks to perform this formatting operation on each commit:
+
+```sh
+$[langkit-query-language]> pre-commit install
 ```
 
 Debugging LKQL JIT
 ------------------
 
-To debug LKQL_JIT native-image build you can use the `debug` maven profile.
+To debug LKQL JIT native-image builds you can use the `debug` maven profile:
 
 ```sh
-$[langkit-query-language/lkql_jit]> mvn clean install -P native,debug
+$[langkit-query-language/lkql_jit]> mvn clean package -P native,debug
 ```
 
-If you need to debug or profile LKQL_JIT native-image binaries there is the `dev` profile which
+If you need to debug or profile LKQL JIT native-image binaries there is the `dev` profile which
 enable support for tools like `valgrind`, `gdb` or `perf` on the produced binaries.
 
 ```sh
-$[langkit-query-language/lkql_jit]> mvn clean install -P native,dev
+$[langkit-query-language/lkql_jit]> mvn clean package -P native,dev
 ```
 
 If you don't need or want any of those, use the `prod` profile to disable all debugging and
 profiling information.
 
 ```sh
-$[langkit-query-language/lkql_jit]> mvn clean install -P native,prod
-```
-
-Configuring Intellij IDEA
--------------------------
-
-To develop for LKQL JIT you may use Intellij IDEA since the LKQL JIT project use and contains a
-configuration for this IDE. You just have to open the LKQL JIT project (`lkql_jit/pom.xml`) with
-Intellij to initialize the project.
-
-However, LKQL JIT project use `google-java-format` to format the Java source code, so you may
-configure Intellij to use this formatter and applying it when saving Java files. To make this
-you have to follow those steps:
-
-### 1) Install Intellij plugin
-
-Go to `File > Settings > Plugins` and search for "google-java-format" in the marketplace then
-install it.
-
-### 2) Enable and configure the Intellij plugin
-
-You now have to enable the "google-java-format" plugin: go to `File > Settings > Other Settings >
-google-java-format Settings` and check the `Enable google-java-format` option. Then you have to
-select the `Android Open Source Project (AOSP) style` in the `Code style` menu.
-
-### 3) Configure the Intellij JRE
-
-The google-java-format plugin uses some internal classes that aren't available without extra
-configuration. You have to go to `Help > Edit Custom VM Options...` then past these lines:
-
-```
---add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED
---add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED
---add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED
---add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED
---add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED
---add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED
+$[langkit-query-language/lkql_jit]> mvn clean package -P native,prod
 ```
-
-Then restart you IDE. Now `google-java-format` should have replaced the `Reformat Code` and
-`Optimize Imports` actions.
-
-### 4) Set formatting hook on file saving (optional)
-
-If you want Intellij to automatically reformat the current file when it is saved you can go to
-`File > Settings > Tools > Actions on save` then check the `Optimize imports` and `Reformat
-code` options.

lkql_jit/TODO.md

@@ -50,6 +50,7 @@
             <groupId>org.graalvm.js</groupId>
             <artifactId>js</artifactId>
             <version>${graalvm.version}</version>
+            <type>pom</type>
         </dependency>
 
         <dependency>
@@ -66,4 +67,4 @@
         </dependency>
     </dependencies>
 
-</project>
+</project>

lkql_jit/benchmarks/pom.xml

@@ -24,8 +24,7 @@ fun baz(x) = {
 
         val clos = foo(12)(13)
         fun r() = clos(14)
-        repeat(1000000, r)
-            """;
+        repeat(1000000, r)""";
 
     private static final String jsClosure =
         """
@@ -47,8 +46,7 @@ function r() {
 
         for (let i = 0; i < 1000000; i++) {
             r()
-        }
-            """;
+        }""";
 
     // ----- Benchmark methods -----
 

lkql_jit/benchmarks/src/test/java/com/adacore/lkql_jit/benchmarks/ClosureBenchmark.java

@@ -27,8 +27,7 @@ function baz(x) {
 
                 for (let i = 0; i < 10000; i++) {
                     foo(12)(13)(14)
-                }
-                        """
+                }"""
             );
     }
 
@@ -47,8 +46,7 @@ fun baz(x) = {
                     bar
                 }
 
-                repeat(10000, () => foo(12)(13)(14))
-                        """
+                repeat(10000, () => foo(12)(13)(14))"""
             );
     }
 }

lkql_jit/benchmarks/src/test/java/com/adacore/lkql_jit/benchmarks/ClosureCreationBenchmark.java

@@ -13,20 +13,6 @@
     <artifactId>builtins_annotations</artifactId>
     <version>0.1.0</version>
 
-    <dependencies>
-        <dependency>
-            <groupId>org.graalvm.truffle</groupId>
-            <artifactId>truffle-api</artifactId>
-            <version>${graalvm.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.graalvm.truffle</groupId>
-            <artifactId>truffle-dsl-processor</artifactId>
-            <version>${graalvm.version}</version>
-            <scope>provided</scope>
-        </dependency>
-    </dependencies>
-
     <build>
         <plugins>
             <!-- Skip the Spotless check because everything is handled by the parent -->
@@ -41,10 +27,9 @@
 
             <plugin>
                 <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.11.0</version>
                 <configuration>
                     <compilerArgs>
-                        <arg>--add-exports</arg>
-                        <arg>org.graalvm.truffle/com.oracle.truffle.api.dsl=ALL-UNNAMED</arg>
                         <compilerArgument>-proc:none</compilerArgument>
                     </compilerArgs>
                 </configuration>