Dmitriy Sukharev. IT Blog

private native int[][] multiply(int[][] a, int[][] b);

private int[][] pureJavaMultiply(int[][] a, int[][] b) {
    int[][] res = new int[a.length][a.length];
    for (int i = 0; i < a.length; i++) {
        for (int j = 0; j < a.length; j++) {
            res[i][j] = 0;
            for (int k = 0; k < a.length; k++) {
                res[i][j] += a[i][k] * b[k][j];
            }
        }
    }
    return res;
}

File sharedLibrary = new File("net_sukharevd_jni_example_MatrixMultiplier.so");
System.load(sharedLibrary.getAbsolutePath());

javac src/net/sukharevd/jni/example/MatrixMultiplier.java

javah -d src/ -cp src/ net.sukharevd.jni.example.MatrixMultiplier

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class net_sukharevd_jni_example_MatrixMultiplier */

#ifndef _Included_net_sukharevd_jni_example_MatrixMultiplier
#define _Included_net_sukharevd_jni_example_MatrixMultiplier
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     net_sukharevd_jni_example_MatrixMultiplier
 * Method:    multiply
 * Signature: ([[I[[I)[[I
 */
JNIEXPORT jobjectArray JNICALL Java_net_sukharevd_jni_example_MatrixMultiplier_multiply
  (JNIEnv *, jobject, jobjectArray, jobjectArray);

#ifdef __cplusplus
}
#endif
#endif

#include <stdlib.h>
#include <jni.h>
#include "net_sukharevd_jni_example_MatrixMultiplier.h"

// Multiplies matrix A to matrix B.
JNIEXPORT jobjectArray JNICALL Java_net_sukharevd_jni_example_MatrixMultiplier_multiply
  (JNIEnv* env, jobject obj, jobjectArray a, jobjectArray b) {

     jint size = (*env)->GetArrayLength(env, a);

     // READ MATRIX B (JVM object) TO BUFFER (native C array)
     int k;
     jintArray* b_sub = malloc(size * sizeof(jintArray*));    // Subarray objects of B,
                                                              // stored for cleaning up.
     jint** buf_b = malloc(size * sizeof(jint*));             // Buffer for matrix B.
     for (k = 0; k < size; k++) {
         b_sub[k] = (*env)->GetObjectArrayElement(env, b, k); // Fetch subarray of B.
         buf_b[k] = (*env)->GetIntArrayElements(env, b_sub[k], NULL); // Read subarray to buffer.
     }

     // CREATE RESULT ARRAY
     jclass intArrCls = (*env)->FindClass(env, "[I");         // Find int[] class.
     if (intArrCls == NULL)
         return NULL; /* exception thrown */
     jobjectArray result = (*env)->NewObjectArray(env, size, intArrCls, NULL);
                                                              // Create array of int[].
     if (result == NULL)
         return NULL; /* out of memory error thrown */
     (*env)->DeleteLocalRef( env, intArrCls );                // Delete reference to int[] class.

     // MULTIPLY MATRICES
     int i, j;
     jint* buf_res_row = (jint*)malloc(size * sizeof(jint));  // Buffer for final matrix.

     for (i = 0; i < size; i++) {
         // READ I-TH ROW FROM A TO BUFFER
         jintArray a_i = (*env)->GetObjectArrayElement(env, a, i);
         jint* buf_a_i = (*env)->GetIntArrayElements(env, a_i, NULL);

         // CALCULATE I-TH ROW OF RESULT
         for (j = 0; j < size; j++) {
             buf_res_row[j] = 0;
             for (k = 0; k < size; k++) {
                 buf_res_row[j] += buf_a_i[k] * buf_b[k][j];
             }
         }

         (*env)->ReleaseIntArrayElements(env, a_i, buf_a_i, 0);
         (*env)->DeleteLocalRef(env, a_i);

         // COPY I-TH ROW TO RESULT OBJECT
         jintArray res_row = (*env)->NewIntArray(env, size);
         if (res_row == NULL)
             return NULL; /* out of memory error thrown */
         (*env)->SetIntArrayRegion(env, res_row, 0, size, buf_res_row); // Firstly copy to new
         (*env)->SetObjectArrayElement(env, result, i, res_row);        // array object, and
         (*env)->DeleteLocalRef(env, res_row);                          // then to matrix.
     }

     // CLEAN UP
     free(buf_res_row);
     for (k = 0; k < size; k++) {
         (*env)->ReleaseIntArrayElements(env, b_sub[k], buf_b[k], 0);
         (*env)->DeleteLocalRef(env, b_sub[k]);
     }
     free(buf_b);
     free(b_sub);

     return result;
}

gcc -O3 -fPIC -shared -I /usr/lib/jvm/java-7-oracle/include/ \
    -I /usr/lib/jvm/java-7-oracle/include/linux/ \
    -o net_sukharevd_jni_example_MatrixMultiplier.so \
    src/net_sukharevd_jni_example_MatrixMultiplier.c

gcc -O3 -shared^
    -I "C:\Program Files\Java\jdk1.7.0_25\include"^
    -I "C:\Program Files\Java\jdk1.7.0_25\include\win32"^
    -o MatrixMultiplier.dll^
    src\net_sukharevd_jni_example_MatrixMultiplier.c

java -cp src/ net.sukharevd.jni.example.MatrixMultiplier

// CALCULATE I-TH ROW OF RESULT
for (j = 0; j < size; j++) {
    buf_res_row[j] = 0;
    for (k = 0; k < size; k++) {

        // !!! NOW B ISN'T BUFFERED ENTIRELY !!!
        jintArray b_k = (*env)->GetObjectArrayElement(env, b, k);
        (*env)->GetIntArrayRegion(env, b_k, j, 1, buf_b_k);
        (*env)->DeleteLocalRef(env, b_k);

        buf_res_row[j] += buf_a_i[k] * buf_b_k[0];
    }
}