Refactor to a POJO for value wrappers.

PullRequest: truffleruby/514

Author: aardvark179

src/main/java/org/truffleruby/Layouts.java

@@ -11,8 +11,6 @@
 
 import com.oracle.truffle.api.object.HiddenKey;
 
-import org.truffleruby.cext.ValueWrapperLayout;
-import org.truffleruby.cext.ValueWrapperLayoutImpl;
 import org.truffleruby.core.HandleLayout;
 import org.truffleruby.core.HandleLayoutImpl;
 import org.truffleruby.core.array.ArrayLayout;
@@ -150,6 +148,5 @@ public abstract class Layouts {
     public static final TracePointLayout TRACE_POINT = TracePointLayoutImpl.INSTANCE;
     public static final DigestLayout DIGEST = DigestLayoutImpl.INSTANCE;
     public static final SystemCallErrorLayout SYSTEM_CALL_ERROR = SystemCallErrorLayoutImpl.INSTANCE;
-    public static final ValueWrapperLayout VALUE_WRAPPER = ValueWrapperLayoutImpl.INSTANCE;
 
 }

src/main/java/org/truffleruby/cext/UnwrapNode.java

@@ -1,12 +1,19 @@
+/*
+ * Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 1.0, or
+ * GNU General Public License version 2, or
+ * GNU Lesser General Public License version 2.1.
+ */
 package org.truffleruby.cext;
 
 import static org.truffleruby.cext.ValueWrapperManager.TAG_MASK;
 import static org.truffleruby.cext.ValueWrapperManager.LONG_TAG;
 import static org.truffleruby.cext.ValueWrapperManager.OBJECT_TAG;
 import static org.truffleruby.cext.ValueWrapperManager.FALSE_HANDLE;
 
-import org.truffleruby.Layouts;
-
 import org.truffleruby.cext.UnwrapNodeGen.UnwrapNativeNodeGen;
 import org.truffleruby.language.NotProvided;
 import org.truffleruby.language.RubyBaseNode;
@@ -76,9 +83,9 @@ public static UnwrapNativeNode create() {
 
     public abstract Object execute(Object value);
 
-    @Specialization(guards = "isWrapper(value)")
-    public Object unwrapValue(DynamicObject value) {
-        return Layouts.VALUE_WRAPPER.getObject(value);
+    @Specialization
+    public Object unwrapValue(ValueWrapper value) {
+        return value.getObject();
     }
 
     @Specialization(guards = "!isWrapper(value)")
@@ -104,6 +111,6 @@ public Object unwrapTypeCastObject(TruffleObject value,
     }
 
     public static boolean isWrapper(TruffleObject value) {
-        return ValueWrapperObjectType.isInstance(value);
+        return value instanceof ValueWrapper;
     }
 }

src/main/java/org/truffleruby/cext/ValueWrapper.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2018 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 1.0, or
+ * GNU General Public License version 2, or
+ * GNU Lesser General Public License version 2.1.
+ */
+package org.truffleruby.cext;
+
+import com.oracle.truffle.api.interop.ForeignAccess;
+import com.oracle.truffle.api.interop.TruffleObject;
+
+/**
+ * This object represents a VALUE in C which wraps the raw Ruby object. This allows foreign access
+ * methods to be set up which convert these value wrappers to native pointers without affecting the
+ * semantics of the wrapped objects.
+ */
+public class ValueWrapper implements TruffleObject {
+
+    private final Object object;
+    private long handle;
+
+    public ValueWrapper(Object object, long handle) {
+        this.object = object;
+        this.handle = handle;
+    }
+
+    public ForeignAccess getForeignAccess() {
+        return ValueWrapperMessageResolutionForeign.ACCESS;
+    }
+
+    public Object getObject() {
+        return object;
+    }
+
+    public long getHandle() {
+        return handle;
+    }
+
+    public void setHandle(long handle) {
+        this.handle = handle;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (!(other instanceof ValueWrapper)) {
+            return false;
+        }
+        ValueWrapper otherWrapper = (ValueWrapper) other;
+        if (handle != ValueWrapperManager.UNSET_HANDLE && otherWrapper.handle != ValueWrapperManager.UNSET_HANDLE) {
+            return handle == otherWrapper.handle;
+        }
+        return (this.object.equals(otherWrapper.object));
+    }
+
+    @Override
+    public int hashCode() {
+        return this.object.hashCode();
+    }
+}

src/main/java/org/truffleruby/cext/ValueWrapperLayout.java

@@ -11,12 +11,10 @@
 
 import java.lang.ref.WeakReference;
 
-import org.truffleruby.Layouts;
 import org.truffleruby.RubyContext;
 import org.truffleruby.collections.LongHashMap;
 import org.truffleruby.extra.ffi.Pointer;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
-import com.oracle.truffle.api.object.DynamicObject;
 
 public class ValueWrapperManager {
 
@@ -39,7 +37,7 @@ public class ValueWrapperManager {
 
     public static final long TAG_MASK = 0b111;
 
-    private final LongHashMap<WeakReference<DynamicObject>> handleMap = new LongHashMap<>(1024);
+    private final LongHashMap<WeakReference<ValueWrapper>> handleMap = new LongHashMap<>(1024);
 
     private final RubyContext context;
 
@@ -52,30 +50,30 @@ public ValueWrapperManager(RubyContext context) {
      * that any given fixnum will translate to a given VALUE.
      */
     @TruffleBoundary
-    public synchronized DynamicObject longWrapper(long value) {
-        return Layouts.VALUE_WRAPPER.createValueWrapper(value, UNSET_HANDLE);
+    public synchronized ValueWrapper longWrapper(long value) {
+        return new ValueWrapper(value, UNSET_HANDLE);
     }
 
-    public DynamicObject doubleWrapper(double value) {
-        return Layouts.VALUE_WRAPPER.createValueWrapper(value, UNSET_HANDLE);
+    public ValueWrapper doubleWrapper(double value) {
+        return new ValueWrapper(value, UNSET_HANDLE);
     }
 
     @TruffleBoundary
-    public synchronized void addToHandleMap(long handle, DynamicObject wrapper) {
+    public synchronized void addToHandleMap(long handle, ValueWrapper wrapper) {
         handleMap.put(handle, new WeakReference<>(wrapper));
     }
 
     @TruffleBoundary
     public synchronized Object getFromHandleMap(long handle) {
-        WeakReference<DynamicObject> ref = handleMap.get(handle);
-        DynamicObject object;
+        WeakReference<ValueWrapper> ref = handleMap.get(handle);
+        ValueWrapper wrapper;
         if (ref == null) {
             return null;
         }
-        if ((object = ref.get()) == null) {
+        if ((wrapper = ref.get()) == null) {
             return null;
         }
-        return Layouts.VALUE_WRAPPER.getObject(object);
+        return wrapper.getObject();
     }
 
     @TruffleBoundary
@@ -84,22 +82,22 @@ public synchronized void removeFromHandleMap(long handle) {
     }
 
     @TruffleBoundary
-    public synchronized long createNativeHandle(DynamicObject wrapper) {
+    public synchronized long createNativeHandle(ValueWrapper wrapper) {
         Pointer handlePointer = Pointer.malloc(1);
         long handleAddress = handlePointer.getAddress();
         if ((handleAddress & TAG_MASK) != 0) {
             throw new RuntimeException("unaligned malloc for native handle");
         }
-        Layouts.VALUE_WRAPPER.setHandle(wrapper, handleAddress);
+        wrapper.setHandle(handleAddress);
         addToHandleMap(handleAddress, wrapper);
         context.getMarkingService().keepObject(wrapper);
         addFinalizer(wrapper, handlePointer);
         return handleAddress;
     }
 
-    public void addFinalizer(DynamicObject wrapper, Pointer handle) {
+    public void addFinalizer(ValueWrapper wrapper, Pointer handle) {
         context.getFinalizationService().addFinalizer(
-                wrapper, null, ValueWrapperObjectType.class,
+                wrapper, null, ValueWrapper.class,
                 createFinalizer(handle), null);
     }
 

src/main/java/org/truffleruby/cext/ValueWrapperManager.java

@@ -9,33 +9,41 @@
  */
 package org.truffleruby.cext;
 
-import org.truffleruby.Layouts;
 import org.truffleruby.RubyContext;
 import org.truffleruby.RubyLanguage;
 
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.interop.CanResolve;
 import com.oracle.truffle.api.interop.MessageResolution;
 import com.oracle.truffle.api.interop.Resolve;
+import com.oracle.truffle.api.interop.TruffleObject;
 import com.oracle.truffle.api.nodes.Node;
-import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.profiles.BranchProfile;
 
-@MessageResolution(receiverType = ValueWrapperObjectType.class)
+@MessageResolution(receiverType = ValueWrapper.class)
 public class ValueWrapperMessageResolution {
 
+    @CanResolve
+    public abstract static class IsInstance extends Node {
+
+        protected boolean test(TruffleObject receiver) {
+            return receiver instanceof ValueWrapper;
+        }
+    }
+
     @Resolve(message = "IS_POINTER")
     public static abstract class ForeignIsPointerNode extends Node {
 
-        protected boolean access(VirtualFrame frame, DynamicObject wrapper) {
+        protected boolean access(VirtualFrame frame, ValueWrapper wrapper) {
             return true;
         }
     }
 
     @Resolve(message = "TO_NATIVE")
     public static abstract class ForeignToNativeNode extends Node {
-        protected Object access(VirtualFrame frame, DynamicObject receiver) {
+        protected Object access(VirtualFrame frame, ValueWrapper receiver) {
             return receiver;
         }
     }
@@ -46,8 +54,8 @@ public static abstract class ForeignAsPointerNode extends Node {
         @CompilationFinal private RubyContext context;
         private final BranchProfile createHandleProfile = BranchProfile.create();
 
-        protected long access(VirtualFrame frame, DynamicObject wrapper) {
-            long handle = Layouts.VALUE_WRAPPER.getHandle(wrapper);
+        protected long access(VirtualFrame frame, ValueWrapper wrapper) {
+            long handle = wrapper.getHandle();
             if (handle == ValueWrapperManager.UNSET_HANDLE) {
                 createHandleProfile.enter();
                 handle = getContext().getValueWrapperManager().createNativeHandle(wrapper);