Update JNIObjectHandles.java

In JNIGlobalHandles created 2 instances of ObjectHandlesImpl (one for strong and one for weak hadles). I divided the total global handels range into two halfs at bit 62. Bit 62 is 0 for strong global handles and 1 for weak global handles. Therefore a validation tag is redused from 32 bit to 31 bit

Author: asselyam

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jni/JNIObjectHandles.java

@@ -65,7 +65,7 @@
  * </ul>
  */
 public final class JNIObjectHandles {
-    @Fold
+    @Fold // replaces with true/false at compile time and removes unnecessary runtime checks
     static boolean haveAssertions() {
         return RuntimeAssertionsSupport.singleton().desiredAssertionStatus(JNIObjectHandles.class);
     }
@@ -219,15 +219,15 @@ public static void deleteLocalRef(JNIObjectHandle localRef) {
             getOrCreateLocals().delete(decodeLocal(localRef));
         }
     }
-
+    // in frames are local handles stored
     public static int pushLocalFrame(int capacity) {
         return getOrCreateLocals().pushFrame(capacity);
     }
 
     public static void popLocalFrame() {
         getExistingLocals().popFrame();
     }
-
+    // pops frames down to a specific starting point identified by the int frame
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
     public static void popLocalFramesIncluding(int frame) {
         getExistingLocals().popFramesIncluding(frame);
@@ -293,19 +293,36 @@ static long computeCurrentGlobalHandleCount() {
  * for example by native code that is unaware of isolates.
  */
 final class JNIGlobalHandles {
-    static final SignedWord MIN_VALUE = Word.signed(Long.MIN_VALUE);
-    static final SignedWord MAX_VALUE = JNIObjectHandles.nullHandle().subtract(1);
+    static final SignedWord MIN_VALUE = Word.signed(Long.MIN_VALUE); // -2^63
+    static final SignedWord MAX_VALUE = JNIObjectHandles.nullHandle().subtract(1); // -1
     static {
         assert JNIObjectHandles.nullHandle().equal(Word.zero());
     }
 
+    // Handle=(MSB)+(Validation Tag)+(Handle Index)
     private static final int HANDLE_BITS_COUNT = 31;
     private static final SignedWord HANDLE_BITS_MASK = Word.signed((1L << HANDLE_BITS_COUNT) - 1);
     private static final int VALIDATION_BITS_SHIFT = HANDLE_BITS_COUNT;
-    private static final int VALIDATION_BITS_COUNT = 32;
+    private static final int VALIDATION_BITS_COUNT = 31;
     private static final SignedWord VALIDATION_BITS_MASK = Word.signed((1L << VALIDATION_BITS_COUNT) - 1).shiftLeft(VALIDATION_BITS_SHIFT);
+    private static final SignedWord WEAK_HANDLE_FLAG = Word.signed(1L << 62);
     private static final SignedWord MSB = Word.signed(1L << 63);
-    private static final ObjectHandlesImpl globalHandles = new ObjectHandlesImpl(JNIObjectHandles.nullHandle().add(1), HANDLE_BITS_MASK, JNIObjectHandles.nullHandle());
+
+    // Define the mid-point to split the range in half
+    private static final SignedWord GLOBAL_RANGE_SPLIT_POINT = Word.signed(1L << 62);
+
+    // Strong global handles will occupy the lower half of the global handles range
+    public static final SignedWord STRONG_GLOBAL_RANGE_MIN = MIN_VALUE;
+    public static final SignedWord STRONG_GLOBAL_RANGE_MAX = GLOBAL_RANGE_SPLIT_POINT.substract(1);
+
+    // Weak global handles will occupy the upper half of the global handles range
+    public static final SignedWord WEAK_GLOBAL_RANGE_MIN = GLOBAL_RANGE_SPLIT_POINT;
+    public static final SignedWord WEAK_GLOBAL_RANGE_MAX = MAX_VALUE;
+
+    private static final ObjectHandlesImpl strongGlobalHandles
+            = new ObjectHandlesImpl(STRONG_GLOBAL_RANGE_MIN.add(1), STRONG_GLOBAL_RANGE_MAX, JNIObjectHandles.nullHandle());
+    private static final ObjectHandlesImpl weakGlobalHandles
+            = new ObjectHandlesImpl(WEAK_GLOBAL_RANGE_MIN.add(1), WEAK_GLOBAL_RANGE_MAX, JNIObjectHandles.nullHandle());
 
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
     static boolean isInRange(JNIObjectHandle handle) {
@@ -317,7 +334,7 @@ private static Word isolateHash() {
         return Word.unsigned(isolateHash);
     }
 
-    private static JNIObjectHandle encode(ObjectHandle handle) {
+    private static JNIObjectHandle encodeStrong(ObjectHandle handle) {
         SignedWord h = (Word) handle;
         if (JNIObjectHandles.haveAssertions()) {
             assert h.and(HANDLE_BITS_MASK).equal(h) : "unencoded handle must fit in range";
@@ -330,6 +347,20 @@ private static JNIObjectHandle encode(ObjectHandle handle) {
         return (JNIObjectHandle) h;
     }
 
+    private static JNIObjectHandle encodeWeak(ObjectHandle handle) {
+        SignedWord h = (Word) handle;
+        if (JNIObjectHandles.haveAssertions()) {
+            assert h.and(HANDLE_BITS_MASK).equal(h) : "unencoded handle must fit in range";
+            Word v = isolateHash().shiftLeft(VALIDATION_BITS_SHIFT);
+            assert v.and(VALIDATION_BITS_MASK).equal(v) : "validation value must fit in its range";
+            h = h.or(v);
+        }
+        h = h.or(MSB);
+        h = h.or(WEAK_HANDLE_FLAG); // Set bit 62 to mark it as weak
+        assert isInRange((JNIObjectHandle) h);
+        return (JNIObjectHandle) h;
+    }
+
     private static ObjectHandle decode(JNIObjectHandle handle) {
         assert isInRange(handle);
         assert ((Word) handle).and(VALIDATION_BITS_MASK).unsignedShiftRight(VALIDATION_BITS_SHIFT)
@@ -338,35 +369,48 @@ private static ObjectHandle decode(JNIObjectHandle handle) {
     }
 
     static <T> T getObject(JNIObjectHandle handle) {
-        return globalHandles.get(decode(handle));
+        SignedWord handleValue = (Word) handle;
+        if (handleValue.greaterOrEqual(STRONG_GLOBAL_RANGE_MIN) && handleValue.lessOrEqual(STRONG_GLOBAL_RANGE_MAX)) {
+            return strongGlobalHandles.get(decode(handle));
+        }
+
+        if (handleValue.greaterOrEqual(WEAK_GLOBAL_RANGE_MIN) && handleValue.lessOrEqual(WEAK_GLOBAL_RANGE_MAX)) {
+            return weakGlobalHandles.get(decode((handle)));
+        }
+
+        throw throwIllegalArgumentException();
     }
 
     static JNIObjectRefType getHandleType(JNIObjectHandle handle) {
-        assert isInRange(handle);
-        if (globalHandles.isWeak(decode(handle))) {
+        SignedWord handleValue = (Word) handle;
+        if (handleValue.greaterOrEqual(STRONG_GLOBAL_RANGE_MIN) && handleValue.lessOrEqual(STRONG_GLOBAL_RANGE_MAX)) {
+            return JNIObjectRefType.Global;
+        }
+
+        if (handleValue.greaterOrEqual(WEAK_GLOBAL_RANGE_MIN) && handleValue.lessOrEqual(WEAK_GLOBAL_RANGE_MAX)) {
             return JNIObjectRefType.WeakGlobal;
         }
-        return JNIObjectRefType.Global;
+        return JNIObjectRefType.Invalid;
     }
 
     static JNIObjectHandle create(Object obj) {
-        return encode(globalHandles.create(obj));
+        return encodeStrong(strongGlobalHandles.create(obj));
     }
 
     static void destroy(JNIObjectHandle handle) {
-        globalHandles.destroy(decode(handle));
+        strongGlobalHandles.destroy(decode(handle));
     }
 
     static JNIObjectHandle createWeak(Object obj) {
-        return encode(globalHandles.createWeak(obj));
+        return encodeWeak(weakGlobalHandles.create(obj));
     }
 
     static void destroyWeak(JNIObjectHandle weakRef) {
-        globalHandles.destroyWeak(decode(weakRef));
+        weakGlobalHandles.destroy(decode(weakRef));
     }
 
     public static long computeCurrentCount() {
-        return globalHandles.computeCurrentCount();
+        return strongGlobalHandles.computeCurrentCount() + weakGlobalHandles.computeCurrentCount();
     }
 }