BytePointer potential optimization for ByteBuffer with backed array

[N0un]

Hi!

I'm looking for a solution to avoid allocation and/or copy if possible (on non direct ByteBuffer with backed array), and reading the BytePointer class I have potential improvement idea.

public BytePointer(ByteBuffer buffer)constructor says:

For direct buffers, calls Pointer(Buffer), while for buffers backed with an array, allocates enough memory for the array and copies it.

I made some research and I figured out that sometimes (and depending on Java implementation) we can access byte[] objects from native side without copy, using JNI methods GetPrimitiveArrayCritical(...) and ReleasePrimitiveArrayCritical(...).

So... Maybe I'm wrong but here is my idea.

Native side

/**
 * Test if current running JVM implementation do a copy
 */
JNIEXPORT jboolean JNICALL Java_..._isNativeDoCopy(JNIEnv* env, jclass, jbyteArray array)
{
	jboolean bIsCopy = false;
	char* pTmp = (char*) env->GetPrimitiveArrayCritical(array, &bIsCopy);
	env->ReleasePrimitiveArrayCritical(array, pTmp, 0);
	
	return bIsCopy;
}

/**
 * Process byte array
 */
JNIEXPORT void JNICALL Java_..._doSomeWork(JNIEnv* env, jclass, jbyteArray array)
{
	char* pArray = (char*) env->GetPrimitiveArrayCritical(array, NULL);

        // Do native work on byte array

	env->ReleasePrimitiveArrayCritical(array, pArray, 0);
}

Java side

private static native boolean isNativeDoCopy(byte[] array);
private static native void doSomeWork(byte[] array);

public static void main(String[] args) {
        // No problem for direct ByteBuffer, BytePointer's mechanism is perfect for that
        ByteBuffer buffer = ByteBuffer.allocate(/*size*/);
        
        if (buffer.hasArray()) {
                // If this condition is true we could process it without copy (it just requires a test once maybe?)
                if (!isNativeDoCopy(new byte[]{0})) {
                        doSomeWork(buffer.array());
                } else {
                        // Allocate, copy, then do some work (BytePointer's current mechanism)
                }
        }
}

I can't find any precise documentation on JNI/JVM implementation variance. But maybe the test (isNativeDoCopy()) could be done once and we can improve BytePointer depending on its result, by avoiding allocation and copy if possible? Or do you already know more informations about that?

[saudet]

Annotate your methods or classes with @CriticalRegion and it will do that.

[N0un]

I'm just talking about the BytePointer and its mechanism. Instantiating it with a direct ByteBuffer is ok (no data copy), but from a ByteBuffer backed with an array, it seems like it always makes a copy.
So, I'm asking on that last thing: maybe we can avoid this copy in the case of GetPrimitiveArrayCritical() can enter the critical region? (By checking if we can enter the critical region, copying address and size and keeping a reference)

In other words:

• Case of direct ByteBuffer:
  no modification (no data copy)
• Case of non direct ByteBuffer backed with an array and JVM can't enter critical region:
  no modification (data copy)
• Case of non direct ByteBuffer backed with an array and JVM can enter critical region:
  Here, my idea is to keep a reference and address, but no copy is needed

[saudet]

Yes, it's already doing that. For a declaration like this:

@CriticalRegion @NoException public static native void foo(ByteBuffer bb);

You'll get this JNI code:

JNIEXPORT void JNICALL Java_NativeLibrary_foo__Ljava_nio_ByteBuffer_2(JNIEnv* env, jclass cls, jobject arg0) {
    signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)env->GetDirectBufferAddress(arg0);
    jbyteArray arr0 = NULL;
    jlong offset0 = 0;
    if (arg0 != NULL && ptr0 == NULL) {
        arr0 = (jbyteArray)env->CallObjectMethod(arg0, JavaCPP_arrayMID);
        offset0 = env->CallIntMethod(arg0, JavaCPP_arrayOffsetMID);
        if (env->ExceptionOccurred() != NULL) {
            env->ExceptionClear();
        } else {
            ptr0 = arr0 == NULL ? NULL : (signed char*)env->GetPrimitiveArrayCritical(arr0, NULL) + offset0;
        }
    }
    jlong position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_bufferPositionFID);
    ptr0 += position0;
    foo(ptr0);
    if (arr0 != NULL) env->ReleasePrimitiveArrayCritical(arr0, ptr0 - position0, 0);
}

[saudet]

If you're talking about the public BytePointer(ByteBuffer buffer) constructor specifically, what do you hope to accomplish? We can't run any Java code between GetPrimitiveArrayCritical() and ReleasePrimitiveArrayCritical(), the JVM is essentially frozen, so if we return from the native function before calling ReleasePrimitiveArrayCritical(), the program will most likely just hang, or in the best case, misbehave. If you return after calling ReleasePrimitiveArrayCritical(), the pointer that you got from GetPrimitiveArrayCritical() is no longer valid, so what do you want to do with it?

[N0un]

We can't run any Java code between GetPrimitiveArrayCritical() and ReleasePrimitiveArrayCritical(), the JVM is essentially frozen

Ok I didn't know that, and this is exactly where I thought we could improve perf... In the JNI documentation there is a lot of warnings about these critical access, but nothing that clear. Sorry, but thank you for your time!

[saudet]

Java arrays are limited to less than 2^31 elements anyway, so they are not that useful anymore to store data. Just use off-heap memory, we can access it just as efficiently from Java: http://bytedeco.org/news/2014/12/23/third-release/