Llamando Rust desde Java

jni

Question

Estoy usando Rust 1.0 beta y pude crear un pequeño ejemplo para llamar a funciones escritas en Rust desde Java. Simplemente compilé el siguiente código Rust en mylib.rs usando rustc que produce un mylib.dll en Windows:

#![crate_type = "dylib"]
use std::any::Any;

#[no_mangle]
pub extern fn Java_tests_Test_hello(env: *const Any, jclass: *const Any) {
    println!("hello from rust");
}

#[no_mangle]
pub extern fn Java_tests_Test_sum(env: *const Any, jclass: *const Any, a: i32, b: i32) -> i32 {
    return a + b;
}

Entonces puedo llamar a estas funciones desde una prueba de clase de Java. Prueba:

package tests;

import java.io.File;

public class Test {

    public static native void hello();

    public static native int sum(int a, int b);

    public static void main(String[] args) {
        File f = new File("mylib.dll");
        System.load(f.getAbsolutePath());
        Test.hello();
        System.out.println(Test.sum(20, 22));
    }
}

Ejecutando el Java principal imprime el resultado esperado:

hello from rust
42

En los métodos de Rust, declaré env como un puntero al tipo Any pero en realidad es una estructura C con punteros a las funciones como se describe en la documentación (Ejemplo de código 4-1) que se requieren para intercambiar datos con el tiempo de ejecución de Java.

De esta answer , entendí que tales estructuras con punteros de función deberían tener una contraparte en el código Rust para llamar a estas funciones. Así que intenté implementar una estructura de este tipo estableciendo todos los valores de campo en *mut Any excepto en el campo GetVersion :

#[repr(C)]
pub struct JavaEnv {

    reserved0: *mut Any,
    reserved1: *mut Any,
    reserved2: *mut Any,
    reserved3: *mut Any,
    GetVersion: extern "C" fn(env: *mut JavaEnv) -> i32,

    DefineClass: *mut Any,
    FindClass: *mut Any,  
    …

Cuando llamo a la siguiente función desde Java, que debería llamar a la función GetVersion, la JVM se bloquea:

#[no_mangle]
pub extern fn Java_tests_Test_helloJre(jre: *mut JavaEnv, class: *const Any) {
    unsafe {
        let v = ((*jre).GetVersion)(jre);
        println!("version: {:?}", v);
    }
}

¿Cómo debo llamar a la función GetVersion correctamente? Tenga en cuenta que soy realmente nuevo en este tipo de cosas, así que no dude en editar esta pregunta si es necesario.

Answer 1

Aparte del problema de que *mut Any / *const Any son punteros geniales, también existe el hecho de que las funciones JNI nativas utilizan doble JNINativeInterface indirecto al acceder a la estructura de JNINativeInterface :

struct JNINativeInterface_;
typedef const struct JNINativeInterface_ *JNIEnv;
jint (JNICALL *GetVersion)(JNIEnv *env);

Aquí, puede ver que JNIEnv es un puntero a la estructura JNINativeInterface_ que en realidad contiene los campos que presentó, y GetVersion acepta un puntero a JNIEnv , es decir, requiere un puntero a un puntero a JNINativeInterface_ . Este programa Rust funciona en mi máquina (se usa Rust nightly pero el mismo código funcionaría en beta con una caja externa de libc):

#![crate_type="dylib"]
#![feature(libc)]
extern crate libc;

use libc::c_void;

#[repr(C)]
pub struct JNINativeInterface {
    reserved0: *mut c_void,
    reserved1: *mut c_void,
    reserved2: *mut c_void,
    reserved3: *mut c_void,

    GetVersion: extern fn(env: *mut JNIEnv) -> i32,

    _opaque_data: [u8; 1824]
}

pub type JNIEnv = *const JNINativeInterface;

#[no_mangle]
pub extern fn Java_tests_Test_helloJre(jre: *mut JNIEnv, class: *const c_void) {
    println!("Invoked native method, jre: {:p}, class: {:p}", jre, class);
    unsafe {
        let v = ((**jre).GetVersion)(jre);
        println!("version: {:?}", v);
    }
}

Contraparte de Java:

package tests;

import java.nio.file.Path;
import java.nio.file.Paths;

public class Test {
    public static native void helloJre();

    public static void main(String[] args) {
        Path p = Paths.get("libtest.dylib");
        System.load(p.toAbsolutePath().toString());
        Test.helloJre();
    }
}

Invocación:

% javac tests/Test.java
% java tests.Test
Invoked native method, jre: 0x7f81240011e0, class: 0x10d9808d8
version: 65544

65544 es 0x10008, y de hecho, estoy ejecutando esto bajo Oracle JVM 1.8.

Supongo que puede omitir el campo _opaque_data ya que la estructura JNINativeInterface siempre se pasa por un puntero, por lo que si solo necesita varios primeros campos de la estructura, puede declararlos solo e ignorar el resto.

Answer 2

Un enfoque más simple sería utilizar JnrFFI . El proyecto JRuby utiliza en gran medida JnrFFI y es probable que forme la base para el nuevo Java FFI JEP . Esto básicamente elimina la escritura de todas las tonterías JNI. Aquí hay un código de ejemplo que usa JnrFFI para llamar a una función Rust desde Java:

Código Java

  public static interface RustLib {
        int double_input(int i);
    }
    public static String getLibraryPath(String dylib) {
        File f = new File(JavaRustFFI.class.getClassLoader().getResource(mapLibraryName(dylib)).getFile());
        return f.getParent();
    }
    public static void main(String[] args) {
        String dylib = "double_input";
        System.setProperty("jnr.ffi.library.path", getLibraryPath(dylib));
        RustLib rlib = LibraryLoader.create(RustLib.class).load(dylib);
        int r = rlib.double_input(20);
        System.out.println("Result from rust double_input:  " + r);
    }

Código de óxido

#[no_mangle]
pub extern fn double_input(input: i32) -> i32 {
    input * 2
}

Aquí está el código completo