Storing instance-related data on C side.

Question

Hello!
I have a question on JNI:
In my class all methods are native. I need to store some instance-related data for my processing.
Is there a way to do this with less overhead than by placing this data to Java class and accessing them through JNI?
I don't need to access to this fields from Java, only from C.
I.e. the solution that I have now is:
Java:
public class stream {
    private int handle = -1;
    public native int open(byte[] szFilename, int mode);
    public native int read(byte[] buffer, int offset, int length);
C:
JNIEXPORT jint JNICALL stream_open (JNIEnv *env , jobject obj , jbyteArray szFilename, jint mode) {
  jclass cls = (*env)->GetObjectClass(env, obj);
  jfieldID fid;
  jint handle;
  fid = (*env)->GetFieldID(env, cls, "handle", "I");
  if (fid == 0)
    return;
  handle = <open>
  (*env)->SetIntField(env, cls, fid, handle);
JNIEXPORT jint JNICALL stream_read (JNIEnv *env, jclass cls, jbyteArray buffer, jint offset, jint length)  {
  jclass cls = (*env)->GetObjectClass(env, obj);
  jfieldID fid;
  jint handle;
  fid = (*env)->GetFieldID(env, cls, "handle", "I");
  if (fid == 0)
    return;
  handle = (*env)->GetIntField(env, cls, fid);
  ... (perform read)
Is it possible to make this more effective, without having 'int handle' in Java? Certainly, it should be different for each instance.
Thank you in advance
Sergey

Answer 1

Your native code is just subroutines, and "normally" data kept around is either local to the subroutine (and disappears between calls), or is global (and so not instance data).
What is not clear from your description is whether you are talking about a) java "instances" for which you want to hold extra data on the C side, or b) you simply have a bunch of C data that you would like to keep around - instances perhaps of some C++ class.
If it is the former, then the likely options are
o Pass the data back to the java side, and hold it in java objects.
o Allocate space on the C side, and pass a pointer to the java object to hold it. (If you do this, save the pointer as a "long".)
o Allocate the space on the C side, setting up some sort of lookup structure, and holding a key in each java object.
One thing to remember is that you need a way to cleanly dispose of C-side data.