Envoi int [] s entre Java et C

J'ai peu de traitement d'image de code Java dans Android qui agit sur deux grandes int tableaux. La plupart du temps, Java est assez rapide, mais j'ai besoin d'utiliser le C via JNI et le NDK pour accélérer un peu d'opérations.

La seule façon que je sais que je peux transmettre les données à partir de l'int des tableaux de C est d'utiliser ByteBuffer.allocateDirect pour créer un nouveau tampon, copiez les données et puis rendre le code C loi sur le tampon.

Cependant, je ne vois aucun moyen que je peux manipuler les données dans cette mémoire tampon en Java, comme si la mémoire tampon a un int[] ou d'un byte[]. Par exemple, un appel à ByteBuffer.array() échouera sur le nouveau tampon. Est-il possible de faire ce travail?

Je dispose de peu de mémoire et que vous souhaitez réduire la façon dont de nombreux tableaux/tampons dont j'ai besoin. Par exemple, ce serait bien si je pouvais utiliser IntBuffer.wrap(new int[...]) pour créer le tampon puis de manipuler le tableau de la sauvegarde de la mémoire tampon directement en Java, mais je ne peux pas le faire parce que la seule chose qui semble fonctionner ici pour JNI est ByteBuffer.allocateDirect.

Existe-il d'autres façons d'envoyer des données en arrière-et-vient entre le C et le Java? Je peux en quelque sorte allouer de la mémoire sur le côté C et de Java est d'envoyer des données directement là-bas?

Edit: Un test comparant l'utilisation de la mémoire tampon de type int[] utilisation:

int size = 1000;
IntBuffer allocateDirect = java.nio.ByteBuffer.allocateDirect(4 * size).asIntBuffer();
for (int i = 0; i < 100; ++i)
{
  for (int x = 0; x < size; ++x)
  {
    int v = allocateDirect.get(x);
    allocateDirect.put(x, v + 1);
  }
}

int[] intArray = new int[size];
for (int i = 0; i < 100; ++i)
{
  for (int x = 0; x < size; ++x)
  {
    int v = intArray[x];
    intArray[x] = v + 1;
  }
}

Sur un téléphone Droid, le tampon version prend environ 10 secondes pour terminer et le tableau version prend ~0.01 secondes.

source d'informationauteur rbcc

  1. 17

    De http://java.sun.com/docs/books/jni/html/objtypes.htmlutiliser JNI du Get/Release<TYPE>ArrayElements(...)

    Dans cet exemple, je vais passer un tableau ( pour la commodité du raisonnement, c'est int array = new int[10] puis le remplir avec des chiffres de 0 à 9

     JNIEXPORT jint JNICALL 
 Java_IntArray_doStuffArray(JNIEnv *env, jobject obj, jintArray arr)
 {

     //initializations, declarations, etc
     jint *c_array;
     jint i = 0;

     //get a pointer to the array
     c_array = (*env)->GetIntArrayElements(env, arr, NULL);

     //do some exception checking
     if (c_array == NULL) {
         return -1; /* exception occurred */
     }

     //do stuff to the array
     for (i=0; i<10; i++) {
         c_array[i] = i;
     }

     //release the memory so java can have it again
     (*env)->ReleaseIntArrayElements(env, arr, c_array, 0);

     //return something, or not.. it's up to you
     return 0;
 }

    Étude de la section 3.3, et plus précisément 3.3.2 -- ce qui vous permettra d'obtenir un pointeur vers le tableau en java de la mémoire, de la modifier, et de le libérer, en effet, vous permettant de modifier le tableau en code natif.

    J'ai simplement utilisé dans mon projet (avec tableaux court) et il fonctionne très bien 🙂

  2. 5

    Si vous utilisez directement allouée tampons, vous pouvez accéder à la sauvegarde de tableau directement à partir de C, à l'aide de la GetDirectBufferAddress fonction. Cela empêche la possibilité de copier des régions de la zone.

    Vous pouvez faire fonctionner l'adresse retournée directement comme vous le feriez pour un C tableau, et il va directement modifier le Java directe de la mémoire tampon allouée.

    Puis, comme ephemient états-unis, vous pouvez utiliser ByteBuffer.asIntBuffer() et de la famille pour accéder à la mémoire tampon d'une manière qui émule les tableaux des différents Java primitives.

    http://download.oracle.com/javase/1.4.2/docs/guide/jni/jni-14.html

  3. 3

    Vous pouvez utiliser la fonction de rappel pour l'envoi des données à partir de natif de la couche de Java.

    En Java couche: dans ma classe native j'ai méthodes suivantes:

    //Native method
public native String getStrData(int size);

//Callback method
public void addData(char[] native_data, int size) {

    ...

}

    En Natif couche: dans mon pays natal, la mise en œuvre:

    JNIEXPORT jstring JNICALL Java_com_pkg_NativeClass_getStrData 
   (JNIEnv *env, jobject obj, jint size) {
     ...

     jclass native_class;           /* Callback: native class */
     jmethodID native_method_id;    /* Callback: native method id */
     jcharArray row;                /* Callback: native data */

     ...

    /* Start Callback: Native to Java  */   
    native_class = (*env)->GetObjectClass(env, obj);
    native_method_id = (*env)->GetMethodID(env, native_class, "addData", "([CI)V");
    if (native_method_id == 0) {
        return (jstring)ERR_NATIVE_METHODID;
    }
    row = (jcharArray)(*env)->NewCharArray(env, size);
    /* jc has the data to be sent to Java */
    (*env)->SetCharArrayRegion(env, (jcharArray)row, (jsize)0, size, (jchar *)jc);

    (*env)->CallVoidMethod(env, obj, native_method_id, row, size);
    /* End Callback */

     ...
}