Przekazywanie wskaźników między C i Javą przez JNI

W C++ możesz użyć dowolnego mechanizmu, który chcesz przydzielić / zwolnić pamięć: stos, malloc / free, new/delete lub dowolną inną niestandardową implementację. Jedynym wymogiem jest to, że jeśli przydzielono blok pamięci z jednym mechanizmem, trzeba go zwolnić z tym samym mechanizmem, więc nie można wywołać {[1] } na zmiennej stosu i nie można wywołać delete na mallocPamięci ed.

JNI ma własne mechanizmy przydzielania / zwalniania JVM pamięć:

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

Są one zgodne z tą samą regułą, jedynym hackiem jest to, że lokalne refy mogą być usuwane "en masse" albo jawnie, z PopLocalFrame, lub pośrednio, gdy natywna metoda kończy działanie.

JNI nie wie, w jaki sposób przydzielono ci pamięć, więc nie może jej zwolnić, gdy funkcja zakończy działanie. Zmienne stosu zostaną oczywiście zniszczone, ponieważ nadal pisanie C++, ale pamięć GPU pozostanie ważna.

Jedynym problemem jest wtedy, jak uzyskać dostęp do pamięci przy kolejnych wywołaniach, a następnie możesz użyć sugestii 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;
    ...
}

Java nie wiedziałaby, co zrobić ze wskaźnikiem, ale powinna być w stanie zapisać wskaźnik z wartości zwracanej przez natywną funkcję, a następnie przekazać go innej natywnej funkcji, aby mogła sobie z nim poradzić. Wskaźniki C są niczym innym jak wartościami liczbowymi w rdzeniu.

Inny kontibutor musiałby ci powiedzieć, czy wskazywana pamięć graficzna zostanie wyczyszczona pomiędzy wywołaniami JNI i czy będą jakieś ograniczenia.

Wiem, że na to pytanie udzielono już oficjalnej odpowiedzi, ale chciałbym dodać swoje rozwiązanie: Zamiast próbować przekazać wskaźnik, umieść wskaźnik w tablicy Java (o indeksie 0) i przekaż go JNI. Kod JNI może pobrać i ustawić element tablicy za pomocą GetIntArrayRegion/SetIntArrayRegion.

W moim kodzie potrzebuję warstwy natywnej do zarządzania deskryptorem pliku (otwartym gniazdem). Klasa Java posiada tablicę int[1] i przekazuje ją do funkcji natywnej. Natywna funkcja może z nim zrobić cokolwiek (get/set) i umieścić z powrotem wynik w tablicy.

Jeśli przydzielasz pamięć dynamicznie (na stercie) wewnątrz natywnej funkcji, nie jest ona usuwana. Innymi słowy, możesz zachować stan pomiędzy różnymi wywołaniami do funkcji natywnych, używając wskaźników, statycznych var, itp.

Pomyśl o tym inaczej: co można bezpiecznie zachować w wywołaniu funkcji, wywołanym z innego programu C++? To samo dotyczy tutaj. Gdy funkcja jest zakończona, wszystko na stosie dla tego wywołania funkcji jest niszczone; ale wszystko na sterta zostanie zachowana, chyba że zostanie usunięta.

Krótka odpowiedź: tak długo, jak nie dealokujesz wyniku, który wracasz do funkcji wywołującej, pozostanie on ważny do ponownego wejścia później. Po prostu posprzątaj, jak skończysz.

Chociaż przyjęta odpowiedź od @ denis-tulskiy ma sens, osobiście śledziłem sugestie z tutaj .

Więc zamiast używać typu pseudo-wskaźnika, takiego jak jlong (lub jint jeśli chcesz zaoszczędzić trochę miejsca na 32-bitowym łuku), użyj ByteBuffer. Na przykład:

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

Które można później ponownie wykorzystać za pomocą:

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

W bardzo prostych przypadkach rozwiązanie to jest bardzo łatwe w użyciu. Załóżmy, że masz:

struct {
  int exampleInt;
  short exampleShort;
} MyNativeStruct;

Po stronie Javy wystarczy, że do:

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

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

Co oszczędza od pisania partii kodu kotła ! Należy jednak zwrócić uwagę na kolejność bajtów, jak wyjaśniono tutaj .

Najlepiej zrobić to dokładnie tak, jak niebezpieczne.allocateMemory tak.

Utwórz swój obiekt, a następnie wpisz go do (uintptr_t), który jest 32/64-bitową niepodpisaną liczbą całkowitą.

return (uintptr_t) malloc(50);

void * f = (uintptr_t) jlong;

Tutaj sprawdzanie stanu zdrowia psychicznego jest niebezpieczne.allocateMemory tak.

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