Introduction to SimpleLanguage
We found the easiest way to get started with implementing your own language by extending an existing SimpleLanguage. SimpleLanguage is a demonstration language built using the Truffle API. The SimpleLanguage project provides a showcase on how to use the Truffle APIs for writing your own language. It aims to use most of the available Truffle framework features and documents their use extensively with inline source documentation.
- Clone the SimpleLanguage repository using
$ git clone https://github.com/graalvm/simplelanguage
- Set the
PATHenvironment variables to the GraalVM home and bin folders using a command-line shell for Linux:
$ export JAVA_HOME=/path/to/graalvm $ export PATH=/path/to/graalvm/bin:$PATH
and for macOS X:
$ export JAVA_HOME=/path/to/graalvm/Contents/Home $ export PATH=/path/to/graalvm/Contents/Home/bin:$PATH
mvn packagefrom SimpleLanguage folder to build the language. The command also builds a
slnativeexecutable in the
sl-component.jarlanguage component which later can be installed into GraalVM using the GraalVM Updater tool. Please verify if
native-imageplugin is available in your GraalVM distribution to avoid the build failure:
$ gu list $ gu install native-image
You can disable the SimpleLanguage native image build during the packaging phase by running:
$ export SL_BUILD_NATIVE=false $ mvn package
- Run in the simplelanguage root folder:
$ ./sl ./language/tests/HelloWorld.sl
The SimpleLanguage demonstration language is licensed under the Universal Permissive License (UPL).
The Truffle Language Implementation framework provides language-agnostic infrastructure to realize standard IDE features by providing additional APIs. If you would like to experiment with your language and get the benefits of an IDE, consider the import of SimpleLanguage as an example.
The SimpleLanguage teaching project has been tested with Eclipse Neon.2 Release 4.6.2 and Eclipse Oxygen.3A. To import the project folder to the desirable Eclipse environment:
- Open Eclipse with a new workspace;
m2e-aptplugins from the Eclipse marketplace (Help -> Eclipse Marketplace);
- Finally, import
SimpleLanguageproject from File -> Import -> Maven -> Existing Maven Projects -> browse to the simplelanguage folder -> Finish.
NetBeans provides GUI support for debugging arbitrary languages. In order to upload SimpleLanguage to NetBeans interface, proceed to File -> Open Project -> select
simplelanguage folder -> check “Open Required Projects” -> open Project.
SimpleLanguage project has been tested with IntelliJ IDEA 2018.3. Open IntelliJ IDEA and, from the main menu bar, select File -> Open -> Navigate to and select the
simplelanguage folder -> Press “OK”. All dependencies will be included automatically.
To run a SimpleLanguage source file, execute
$ ./sl language/tests/HelloWorld.sl
To see assembly code for Truffle compiled functions, run
$ ./sl -disassemble language/tests/SumPrint.sl
To investigate performance issues, we recommend the Ideal Graph Visualizer (here and after “IGV”) – an essential tool for any language implementer building on top of GraalVM Enterprise Edition. It is available as a separate download on Oracle Technology Network and requires accepting the Oracle Technology Network Developer License.
1.Unzip the downloaded package, enter the
bin directory and start IGV:
$ cd idealgraphvisualizer/bin $ idealgraphvisualizer
2.Execute the following from simplelanguage root folder to dump graphs to IGV:
$ ./sl -dump language/tests/SumPrint.sl
To start debugging the SimpleLanguage implementation with a Java debugger, pass the
-debug option to the command-line launcher of your program:
$ ./sl -debug language/tests/HelloWorld.sl
Then attach a Java remote debugger (like Eclipse) on port 8000.
SimpleLanguage Component for GraalVM
Languages implemented with Truffle Language Implementation framework can be packaged as Components which later can be installed into
GraalVM using the GraalVM Updater.
mvn package in the simplelanguage folder also builds a
This file is the SimpleLanguage component for GraalVM and can be installed by
$ gu -L install /path/to/sl-component.jar
SimpleLanguage Native Image
A language implemented with Truffle Language Implementation framework can be AOT
compiled using the GraalVM Native Image. Running
mvn package in the simplelanguage folder also builds a
native directory. This executable is the full SimpleLanguage
implementation as a single native application, and has no need for a GraalVM in
order to execute SimpleLanguage code. Besides this, a big advantage of using the
native image when compared to running on the GraalVM is the greatly faster
startup time as shown bellow.
$ time ./sl language/tests/HelloWorld.sl == running on org.graalvm.polyglot.Engine@2db0f6b2 Hello World! real 0m0.405s user 0m0.660s sys 0m0.108s $ time ./native/slnative language/tests/HelloWorld.sl == running on org.graalvm.polyglot.Engine@7fd046f06898 Hello World! real 0m0.004s user 0m0.000s sys 0m0.000s
This snipped shows a timed execution of a “Hello World” program using the sl launcher script, which runs SimpleLanguage on GraalVM, and using the native image. We can see that when running on GraalVM the execution takes 405ms. Since our SimpleLanguage program does just one print statement, we can conclude that almost all of this time is spent starting up GraalVM and initializing the language itself. When using the native image we see that the execution takes only 4ms, showing two orders of magnitude faster startup than running on the GraalVM.
For more information on the
native-image tool consider reading the reference
Disable SimpleLanguage Native Image Build
Building the native image through maven is attached to the maven
phase. Since the native image build can take a bit of time, we provide the
option to skip this build by setting the
SL_BUILD_NATIVE environment variable
false like so:
$ export SL_BUILD_NATIVE=false $ mvn package ... [INFO] [INFO] ------------------------------------------------------------------------ [INFO] Building simplelanguage-graalvm-native [INFO] ------------------------------------------------------------------------ [INFO] [INFO] --- exec-maven-plugin:1.6.0:exec (make_native) @ simplelanguage-graalvm-native --- Skipping the native image build because SL_BUILD_NATIVE is set to false. [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ ...
Run SimpleLanguage with the Newest Compiler Version
In the outstanding case that you need to execute SimpleLanguage with the newest version of the GraalVM compiler, please follow these instructions:
- Download the latest JVMCI JDK 8 and point JAVA_HOME at it:
$ export JAVA_HOME=/path/to/openjdk1.8.0_212-jvmci-19.2-b01
- Clone the “Graal” repository from SimpleLanguage folder:
$ cd /path/to/simplelanguage $ git clone https://github.com/oracle/graal.git
- Clone the mx repository:
$ git clone https://github.com/graalvm/mx.git
- Add mx to your path:
$ export PATH=/path/to/mx:$PATH
- Navigate to the compiler folder:
$ cd /path/to/graal/compiler
- Build the GraalVM compiler:
$ mx build
- Run SimpleLanguage using the mx command:
$ mx -v --jdk=jvmci vm -cp /path/to/simplelanguage/launcher/target/launcher-19.0.2-SNAPSHOT.jar:/path/to/simplelanguage/language/target/simplelanguage.jar com.oracle.truffle.sl.launcher.SLMain /path/to/simplelanguage/language/tests/SlScript.sl
Run SimpleLanguage Using Command Line
Executing SimpleLanguage code is normally done with the
sl script which sets
up the necessary command line depending on whether
JAVA_HOME points to the
GraalVM or another JVM installation. The following subsections describe the
command line for both cases.
JAVA_HOME points to the GraalVM installation and that the current
working directory is the
simplelanguage directory, to run SimpleLanguage one
should execute the following command:
$ JAVA_HOME/bin/java \ -cp launcher/target/launcher-19.0.2-SNAPSHOT.jar \ -Dtruffle.class.path.append=language/target/simplelanguage.jar \ com.oracle.truffle.sl.launcher.SLMain language/tests/Add.sl
In short, we place the launcher jar on the class path and execute its main
class, but we inform GraalVM of the presence of SimpleLanguage by using the
-Dtruffle.class.path.append option and providing it the path to the fat
language jar. Having the language on a separate class path ensures a strong
separation between the language implementation and its embedding context (in
this case, the launcher).
Disable Class Path Separation
NOTE! This should only be used during development.
If it is required to disable the class path separation and enable having the
language implementation on the application class path (for example, for testing
the internals of the language) you can add the
option. This disables the class path isolation, enabling the language
implementation to be placed on the application class path. The command line can
then look like the following.
$ JAVA_HOME/bin/java \ -XX:-UseJVMCIClassLoader \ -cp launcher/target/launcher-19.0.2-SNAPSHOT.jar:language/target/simplelanguage.jar \ com.oracle.truffle.sl.launcher.SLMain language/tests/Add.sl
Other JVM Implementations
Unlike GraalVM, which includes all the dependencies needed to run a language implemented with Truffle framework, other JVM implementations need additional jars to be present on the class path. These are the Truffle API and GraalVM SDK jars available from Maven Central.
JAVA_HOME points to a Stock JDK installation, that the current
working directory is the
simplelanguage directory and the Truffle API and
GraalVM SDK jars are present in that directory, one can execute SimpleLanguage
with the following command:
$ JAVA_HOME/bin/java \ -cp graal-sdk-19.0.2.jar:truffle-api-19.0.2.jar:launcher/target/launcher-19.0.2-SNAPSHOT.jar:language/target/simplelanguage.jar \ com.oracle.truffle.sl.launcher.SLMain language/tests/Add.sl