Create JVM with options

Author: JaroslavTulach

lib/java/os-environment/src/main/java/module-info.java

@@ -9,6 +9,7 @@
   requires org.apache.commons.io;
 
   exports org.enso.os.environment;
+  exports org.enso.os.environment.jni;
   exports org.enso.os.environment.chdir;
   exports org.enso.os.environment.trash;
   exports org.enso.os.environment.directories;

lib/java/os-environment/src/main/java/org/enso/os/environment/jni/JNI.java

@@ -18,30 +18,25 @@
 import org.graalvm.word.PointerBase;
 
 @CContext(JNIDirectives.class)
-final class JNI {
+public final class JNI {
   @CConstant
   static native int JNI_OK();
 
   @CConstant
   static native int JNI_ERR();
 
-  /* unknown error */
   @CConstant
   static native int JNI_EDETACHED();
 
-  /* thread detached from the VM */
   @CConstant
   static native int JNI_EVERSION();
 
-  /* JNI version error */
   @CConstant
   static native int JNI_ENOMEM();
 
-  /* not enough memory */
   @CConstant
   static native int JNI_EEXIST();
 
-  /* VM already created */
   @CConstant
   static native int JNI_EINVAL();
 

lib/java/os-environment/src/main/java/org/enso/os/environment/jni/JNINativeInterface.java

@@ -7,7 +7,7 @@
 
 @CContext(value = JNIDirectives.class)
 @CStruct(value = "JNINativeInterface_", addStructKeyword = true)
-interface JNINativeInterface extends PointerBase {
+public interface JNINativeInterface extends PointerBase {
 
   @CField(value = "NewString")
   JNI.NewString getNewString();

lib/java/os-environment/src/main/java/org/enso/os/environment/jni/JVM.java

@@ -2,14 +2,20 @@
 
 import org.enso.common.Platform;
 import org.graalvm.nativeimage.StackValue;
+import org.graalvm.nativeimage.UnmanagedMemory;
+import org.graalvm.nativeimage.c.struct.SizeOf;
+import org.graalvm.nativeimage.c.type.CTypeConversion;
 import org.graalvm.word.WordFactory;
 
+/** Represents a JVM inside of current process. */
 public final class JVM {
   private final JNIBoot.JNICreateJavaVMPointer createJvmFn;
+  private final String[] options;
   private JNI.JNIEnv env = WordFactory.nullPointer();
 
-  JVM(JNIBoot.JNICreateJavaVMPointer factory) {
+  JVM(JNIBoot.JNICreateJavaVMPointer factory, String[] options) {
     this.createJvmFn = factory;
+    this.options = options;
   }
 
   /**
@@ -19,11 +25,13 @@ public final class JVM {
    * @param javaHome path where the JDK is installed
    * @return new instance of the JVM
    */
-  public static JVM create(String javaHome) {
-    return switch (Platform.getOperatingSystem()) {
-      case WINDOWS -> WindowsJVM.createImpl(javaHome);
-      case LINUX, MACOS -> PosixJVM.createImpl(javaHome);
-    };
+  public static JVM create(String javaHome, String... options) {
+    var createJvmFn =
+        switch (Platform.getOperatingSystem()) {
+          case WINDOWS -> WindowsJVM.createImpl(javaHome);
+          case LINUX, MACOS -> PosixJVM.createImpl(javaHome);
+        };
+    return new JVM(createJvmFn, options);
   }
 
   /**
@@ -40,18 +48,31 @@ public final JNI.JNIEnv env() {
 
   private synchronized JNI.JNIEnv initializeEnv() {
     var jvmArgs = StackValue.get(JNIBoot.Args.class);
-    jvmArgs.nOptions(0);
-    var options = StackValue.get(1, JNIBoot.Option.class);
-    jvmArgs.options(options);
+    jvmArgs.nOptions(options.length);
+    var sizeOfOption = SizeOf.get(JNIBoot.Option.class);
+    JNIBoot.Option jvmOpts = UnmanagedMemory.calloc(options.length * sizeOfOption);
+    var holder = new CTypeConversion.CCharPointerHolder[options.length];
+    for (var i = 0; i < options.length; i++) {
+      holder[i] = CTypeConversion.toCString(options[i]);
+      var nth = jvmOpts.addressOf(i);
+      nth.setOptionString(holder[i].get());
+      nth.setExtraInfo(WordFactory.nullPointer());
+    }
+    jvmArgs.options(jvmOpts);
     jvmArgs.version(JNI.JNI_VERSION_10());
-    jvmArgs.nOptions(0);
     jvmArgs.ignoreUnrecognized(false);
 
     var jvmPtr = StackValue.get(JNI.JavaVMPointer.class);
     var envPtr = StackValue.get(JNI.JNIEnvPointer.class);
 
     int res = createJvmFn.call(jvmPtr, envPtr, jvmArgs);
-    assert res == 0;
+    assert res == 0 : "Error creating JVM: " + res;
+
+    for (var i = 0; i < options.length; i++) {
+      holder[i].close();
+    }
+    UnmanagedMemory.free(jvmOpts);
+
     return envPtr.readJNIEnv();
   }
 }

lib/java/os-environment/src/main/java/org/enso/os/environment/jni/PosixJVM.java

@@ -12,13 +12,7 @@
 
 @CContext(PosixJVM.Direct.class)
 final class PosixJVM {
-
-  static JVM createImpl(String javaHome) {
-    var createJvmFn = findCreateJavaSymbol(javaHome);
-    return new JVM(createJvmFn);
-  }
-
-  private static JNIBoot.JNICreateJavaVMPointer findCreateJavaSymbol(String javaHome) {
+  static JNIBoot.JNICreateJavaVMPointer createImpl(String javaHome) {
     var libJvmPath = findDynamicLibrary(javaHome).getPath();
     try (var libPath = CTypeConversion.toCString(libJvmPath);
         var createJvm = CTypeConversion.toCString("JNI_CreateJavaVM")) {

lib/java/os-environment/src/main/java/org/enso/os/environment/jni/WindowsJVM.java

@@ -15,16 +15,14 @@
 
 @CContext(WindowsJVM.Direct.class)
 final class WindowsJVM {
-  static JVM createImpl(String javaHome) {
+  static JNICreateJavaVMPointer createImpl(String javaHome) {
     var dllPath = findDynamicLibrary(javaHome).getPath();
 
     try (var libPath = CTypeConversion.toCString(dllPath);
         var createJvm = CTypeConversion.toCString("JNI_CreateJavaVM")) {
       var dll = LoadLibraryA(libPath.get());
       assert dll.isNonNull();
-      JNICreateJavaVMPointer cStringCreateJvm = GetProcAddress(dll, createJvm.get());
-
-      return new JVM(cStringCreateJvm);
+      return GetProcAddress(dll, createJvm.get());
     }
   }
 

lib/java/os-environment/src/test/java/org/enso/os/environment/jni/LoadClassTest.java

@@ -3,16 +3,25 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
+import org.enso.os.environment.jni.JNI.JValue;
 import org.graalvm.nativeimage.StackValue;
 import org.graalvm.nativeimage.c.type.CTypeConversion;
 import org.junit.Test;
 
 public class LoadClassTest {
   private static final String PATH = System.getProperty("java.home");
+  private static JVM jvm;
+
+  private static JNI.JNIEnv env() {
+    if (jvm == null) {
+      jvm = JVM.create(PATH, "-Dsay=Ahoj");
+    }
+    return jvm.env();
+  }
 
   @Test
   public void invokeParseShortMethod() {
-    var env = JVM.create(PATH).env();
+    var env = env();
     assertTrue("JNI created", env.isNonNull());
 
     var findClassFn = env.getFunctions().getFindClass();
@@ -38,4 +47,44 @@ public void invokeParseShortMethod() {
       assertEquals(345, res);
     }
   }
+
+  @Test
+  public void setSystemProperty() {
+    var env = env();
+    assertTrue("JNI created", env.isNonNull());
+
+    var findClassFn = env.getFunctions().getFindClass();
+    var getStaticMethodIDFn = env.getFunctions().getGetStaticMethodID();
+    var newStringFn = env.getFunctions().getNewStringUTF();
+    var strLengthFn = env.getFunctions().getGetStringUTFLength();
+    var strCharsFn = env.getFunctions().getGetStringUTFChars();
+    var strReleaseFn = env.getFunctions().getReleaseStringUTFChars();
+    var callStaticMethodFn = env.getFunctions().getCallStaticObjectMethodA();
+
+    try (var systemName = CTypeConversion.toCString("java/lang/System");
+        var getPropertyName = CTypeConversion.toCString("getProperty");
+        var getPropertySig = CTypeConversion.toCString("(Ljava/lang/String;)Ljava/lang/String;");
+        var propName = CTypeConversion.toCString("say"); ) {
+      var System = findClassFn.call(env, systemName.get());
+
+      assertTrue("System class is loaded", System.isNonNull());
+
+      var valueOf =
+          getStaticMethodIDFn.call(env, System, getPropertyName.get(), getPropertySig.get());
+      assertTrue("getProperty method found", valueOf.isNonNull());
+
+      var args = StackValue.get(JNI.JValue.class);
+      var str = newStringFn.call(env, propName.get());
+      args.setJObject(str);
+      var res = (JNI.JString) callStaticMethodFn.call(env, System, valueOf, args);
+      assertTrue("There should be a property 'say' defined", res.isNonNull());
+      var len = strLengthFn.call(env, res);
+      assertEquals("'Ahoj' has four letters", 4, len);
+      var valueFalse = StackValue.get(JValue.class);
+      valueFalse.setBoolean(false);
+      var chars = strCharsFn.call(env, res, valueFalse);
+      assertEquals("Ahoj", CTypeConversion.toJavaString(chars));
+      strReleaseFn.call(env, res, chars);
+    }
+  }
 }