通过 JNI 在 C 和 Java 之间传递指针

Question

目前，我正在尝试创建一个使用 CUDA 功能的 Java 应用程序。 CUDA和Java之间的连接工作正常，但我有另一个问题，想问我的想法是否正确。

当我从 Java 调用本机函数时，我向它传递一些数据，函数计算一些内容并返回结果。是否可以让第一个函数返回对此结果的引用（指针），我可以将其传递给 JNI 并调用另一个对结果进行进一步计算的函数？

我的想法是通过将数据保留在 GPU 内存中并仅传递对其的引用以便其他函数可以使用它来减少将数据复制到 GPU 或从 GPU 复制数据所带来的开销。

尝试了一段时间后，我自己想，这应该是不可能的，因为指针在应用程序结束后被删除（在本例中，当 C 函数终止时）。这是正确的吗？或者我只是 C 语言太差而无法看到解决方案？

编辑： 好吧，稍微扩展一下问题（或者使其更清楚）：当函数结束时，JNI 本机函数分配的内存是否会被释放？或者我是否仍然可以访问它，直到 JNI 应用程序结束或手动释放它？

感谢您的投入:)

Answer 1

Java 不知道如何处理指针，但它应该能够存储本机函数返回值的指针，然后将其交给另一个本机函数来处理。 C 指针的核心只不过是数值。

另一个贡献者必须告诉您在 JNI 调用之间是否会清除指向的图形内存以及是否有任何解决方法。

Answer 2

我知道这个问题已经得到正式回答，但我想添加我的解决方案：
不要尝试传递指针，而是将指针放入 Java 数组（索引 0 处）并将其传递给 JNI。 JNI 代码可以使用 GetIntArrayRegion/SetIntArrayRegion 获取和设置数组元素。

在我的代码中，我需要本机层来管理文件描述符（打开的套接字）。 Java 类保存一个 int[1] 数组并将其传递给本机函数。本机函数可以用它执行任何操作（获取/设置）并将结果放回数组中。

Answer 3

如果您在本机函数内部动态分配内存（在堆上），则不会删除它。换句话说，您可以使用指针、静态变量等来保留对本机函数的不同调用之间的状态。以

不同的方式思考：您可以在从另一个 C++ 程序调用的函数调用中安全地保留什么？同样的事情也适用于此。当函数退出时，该函数调用的堆栈上的所有内容都会被销毁；但堆上的任何内容都会保留，除非您明确删除它。

简短的回答：只要您不释放返回给调用函数的结果，它将在以后重新进入时保持有效。只要确保完成后将其清理干净即可。

Answer 4

最好按照 Unsafe.allocateMemory 的方式执行此操作。

创建对象，然后将其键入 (uintptr_t)，这是一个 32/64 位无符号整数。

return (uintptr_t) malloc(50);

void * f = (uintptr_t) jlong;

这是唯一正确的方法。

这是 Unsafe.allocateMemory 所做的健全性检查。

inline jlong addr_to_java(void* p) {
  assert(p == (void*)(uintptr_t)p, "must not be odd high bits");
  return (uintptr_t)p;
}

UNSAFE_ENTRY(jlong, Unsafe_AllocateMemory(JNIEnv *env, jobject unsafe, jlong size))
  UnsafeWrapper("Unsafe_AllocateMemory");
  size_t sz = (size_t)size;
  if (sz != (julong)size || size < 0) {
    THROW_0(vmSymbols::java_lang_IllegalArgumentException());
  }
  if (sz == 0) {
    return 0;
  }
  sz = round_to(sz, HeapWordSize);
  void* x = os::malloc(sz, mtInternal);
  if (x == NULL) {
    THROW_0(vmSymbols::java_lang_OutOfMemoryError());
  }
  //Copy::fill_to_words((HeapWord*)x, sz / HeapWordSize);
  return addr_to_java(x);
UNSAFE_END

Answer 5

这是另一种方法，在 java-c C 胶水文件中使用全局静态变量，通过引用将该变量传递给 C，并返回已从 C 更改为 Java 的变量。不过需要两个 Java 函数调用。

下面是一个在 Kotlin 中使用 Android 开发的示例：

首先，C 代码（一个简单的函数，递增通过引用传递的变量）：

// lib.c
void cfunction(int *number)
{
    *number += 1;
}

然后我们通常有另一个像胶水一样使用的 C 代码，来管理 Java idiocies特性

// glue.c
static int number;

void cfunction(int *);

JNIEXPORT void JNICALL
Java_com_example_someapp_MainActivity_inc(JNIEnv* env, jobject thiz, jint value)
{
    number = value;
    cfunction(&number);
}

JNIEXPORT jint JNICALL
Java_com_example_someapp_MainActivity_getnumber(JNIEnv* env, jobject thiz)
{
    return number;
}

它使用全局变量number（由于static关键字，只能在文件glue.c内访问），并且可以使用getter函数getnumber<在外部访问/代码>。所以基本上我们需要一个附加函数和一个静态全局变量来调用需要指针并更改其引用的 C 库。

CMakeLists.txt 看起来像：

cmake_minimum_required(VERSION 3.18.1)

project("someapp")

add_library(somelib SHARED
            glue.c
            lib.c)

最后 Android (Kotlin) 部分：

package com.example.someapp

// imports

class MainActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // How to use a C call by ref in Kotlin
        inc(4)
        val number = getnumber()
        Toast.makeText(this, number.toString(), Toast.LENGTH_LONG).show()
    }

    external fun inc(number: Int)

    external fun getnumber(): Int

    companion object {
        init {
            System.loadLibrary("somelib")
        }
    }
}

它应该显示 5。

Answer 6

虽然 @denis-tulskiy 接受的答案确实有道理，但我个人遵循 此处。

因此，不要使用伪指针类型，例如 jlong​​（如果您想在 32 位架构上节省一些空间，则使用 jint），而应使用 ByteBuffer代码>.例如：

MyNativeStruct* data; // Initialized elsewhere.
jobject bb = (*env)->NewDirectByteBuffer(env, (void*) data, sizeof(MyNativeStruct));

您稍后可以将其重复使用：

jobject bb; // Initialized elsewhere.
MyNativeStruct* data = (MyNativeStruct*) (*env)->GetDirectBufferAddress(env, bb);

对于非常简单的情况，此解决方案非常易于使用。假设您：

struct {
  int exampleInt;
  short exampleShort;
} MyNativeStruct;

在 Java 方面，您只需要做：

public int getExampleInt() {
  return bb.getInt(0);
}

public short getExampleShort() {
  return bb.getShort(4);
}

这可以让您免于编写大量样板代码！然而，人们应该注意字节顺序，如此处所述。

Answer 7

我使用了以下方法：

在 JNI 代码中，创建一个结构体来保存对所需对象的引用。当您第一次创建此结构时，将其指针作为 long 返回到 java。然后，在 java 中，您只需使用此 long 作为参数调用任何方法，并在 C 中将其转换为指向结构的指针。

该结构将位于堆中，因此在不同的 JNI 调用之间不会被清除。

编辑：我认为您不能使用 long ptr = (long)&address; 因为地址是静态变量。按照 Gunslinger47 建议的方式使用它，即创建类或结构的新实例（使用 new 或 malloc）并传递其指针。

Answer 8

在 C++ 中，您可以使用任何想要分配/释放内存的机制：堆栈、malloc/free、new/delete 或任何其他自定义实现。唯一的要求是，如果您使用一种机制分配了一块内存，则必须使用相同的机制释放它，因此您不能在堆栈变量上调用 free ，也不能调用删除对malloc分配的内存。

JNI 有自己的分配/释放 JVM 内存的机制：

• NewObject/DeleteLocalRef
• NewGlobalRef/DeleteGlobalRef
• NewWeakGlobalRef/DeleteWeakGlobalRef

这些遵循相同的规则，唯一的问题是本地引用可以通过 PopLocalFrame< 显式删除“批量” /code>，或隐式地，当本机方法退出时。

JNI 不知道您如何分配内存，因此当您的函数退出时它无法释放它。堆栈变量显然会被破坏，因为您仍在编写 C++，但您的 GPU 内存将保持有效。

那么唯一的问题是如何在后续调用中访问内存，然后您可以使用 Gunslinger47 的建议：

JNIEXPORT jlong JNICALL Java_MyJavaClass_Function1() {
    MyClass* pObject = new MyClass(...);
    return (long)pObject;
}

JNIEXPORT void JNICALL Java_MyJavaClass_Function2(jlong lp) {
    MyClass* pObject = (MyClass*)lp;
    ...
}