To answer that question you could write a little simulation program
that just transfers random gibberish around.

It's not immediately clear what you would gain by doing so -- since you already
have the working C++ code (I assume), and since the change wouldn't allow you
to eliminate JNI/C++ completely, it's not obvious to me that there's a net
gain.

Anyway...

Some things to be aware of.

There should be no problem at all with transferring such relatively small
amounts of data across the Java/C++ interface.  JNI has a relatively high
overhead per call, but you wouldn't be making a JNI call for each int, but only
a small number per /array/.

A C++ int[][] array does not have the same layout as a Java int[][] array --
the former is a single contiguous chunk of memory where each access is compiled
into a combination of multiply and add to find the corresponding index.  In
Java 2d array is actually an array of arrays, so accessing an item requires an
array lookup, an indirection, and another array lookup.  There are two
problems with that; the first is that you would have to transform the C++
layout into Java layout (not difficult, but it does add mess to the code since
you'd have to create and populate each sub-array separately); the second is
that the Java code would take a (fairly small, but possibly still significant)
performance hit.  You could avoid both problems by treating the data as a
single large int[] array in Java, but that would complicate your Java code,
since you'd have to write the multiply-and-add stuff yourself rather than
having the compiler do it for you.

So the question doesn't really have as lot to do with JNI -- it's more a
question of whether the gains (whatever they are to you) of (re)writing the
data-manipulation code in Java are worth either a performance hit or added
complexity.

   -- chris

You may want to take a look at Jenie,
http://www.servertec.com/products/jenie/jenie.html. Among other things it
will allow you to efficiently access, update and manage native resources,
like your large native array from Java without having to copy it up to Java.
Using Jenie you can also directly access native libraries without having to
use JNI and without having to write C/C++ code. No more JNI nightmares or
worries. Internally it is doing all the JNI stuff for you.

Can you allocate the space on the java side and pass a reference to it
to your C++ pgm and have the C++ pgm put the data into the java array?

Use direct ByteBuffer/IntBuffers and you dont need to copy the actual
data, just pointer to a table.