[GR-8654] Native array storage.

PullRequest: truffleruby/1003

Author: aardvark179

CHANGELOG.md

@@ -36,6 +36,7 @@ Compatibility:
 * Implemented the `unit` argument of `Time.at` (#1791, @XrXr).
 * Implemented `keyword_init: true` for `Struct.new` (#1789, @XrXr).
 * Implemented `MatchData#dup` (#1792, @XrXr).
+* Implemented a native storage strategy for arrays to allow better C extension compatibility.
 
 Performance:
 

lib/truffle/truffle/cext.rb

@@ -195,7 +195,8 @@ def polyglot_pointer?
     end
 
     def polyglot_address
-      raise RuntimeError, 'RARRAY_PTRs cannot be converted to native pointers yet'
+      TrufflePrimitive.array_store_to_native(@array)
+      TrufflePrimitive.array_store_address(@array)
     end
 
     # Every IS_POINTER object should also have TO_NATIVE

spec/ruby/optional/capi/array_spec.rb

@@ -249,6 +249,14 @@
       @s.RARRAY_PTR_assign(a, :set)
       a.should == [:set, :set, :set]
     end
+
+    it "allows memcpying between arrays" do
+      a = [1, 2, 3]
+      b = [0, 0, 0]
+      @s.RARRAY_PTR_memcpy(a, b)
+      b.should == [1, 2, 3]
+      a.should == [1, 2, 3] # check a was not modified
+    end
   end
 
   describe "RARRAY_LEN" do

spec/ruby/optional/capi/ext/array_spec.c

@@ -33,6 +33,19 @@ static VALUE array_spec_RARRAY_PTR_assign(VALUE self, VALUE array, VALUE value)
   return Qnil;
 }
 
+
+static VALUE array_spec_RARRAY_PTR_memcpy(VALUE self, VALUE array1, VALUE array2) {
+  VALUE *ptr1, *ptr2;
+  int size;
+  size = RARRAY_LEN(array1);
+  ptr1 = RARRAY_PTR(array1);
+  ptr2 = RARRAY_PTR(array2);
+  if (ptr1 != NULL && ptr2 != NULL) {
+    memcpy(ptr2, ptr1, size * sizeof(VALUE));
+  }
+  return Qnil;
+}
+
 static VALUE array_spec_RARRAY_LEN(VALUE self, VALUE array) {
   return INT2FIX(RARRAY_LEN(array));
 }
@@ -229,6 +242,7 @@ void Init_array_spec(void) {
   rb_define_method(cls, "RARRAY_LEN", array_spec_RARRAY_LEN, 1);
   rb_define_method(cls, "RARRAY_PTR_iterate", array_spec_RARRAY_PTR_iterate, 1);
   rb_define_method(cls, "RARRAY_PTR_assign", array_spec_RARRAY_PTR_assign, 2);
+  rb_define_method(cls, "RARRAY_PTR_memcpy", array_spec_RARRAY_PTR_memcpy, 2);
   rb_define_method(cls, "RARRAY_AREF", array_spec_RARRAY_AREF, 2);
   rb_define_method(cls, "rb_ary_aref", array_spec_rb_ary_aref, -1);
   rb_define_method(cls, "rb_ary_clear", array_spec_rb_ary_clear, 1);

src/main/c/cext/ruby.c

@@ -1497,7 +1497,7 @@ VALUE rb_Array(VALUE array) {
 }
 
 VALUE *RARRAY_PTR_IMPL(VALUE array) {
-  return (VALUE *) RUBY_CEXT_INVOKE_NO_WRAP("RARRAY_PTR", array);
+  return (VALUE *) polyglot_as_i64_array(RUBY_CEXT_INVOKE_NO_WRAP("RARRAY_PTR", array));
 }
 
 VALUE rb_ary_new() {

src/main/c/zlib/zlib.c

@@ -3032,8 +3032,6 @@ typedef struct {
     VALUE klass;
 } new_wrap_arg_t;
 
-POLYGLOT_DECLARE_TYPE(new_wrap_arg_t)
-
 static VALUE
 new_wrap(VALUE tmp)
 {
@@ -3060,11 +3058,11 @@ gzfile_wrap(int argc, VALUE *argv, VALUE klass, int close_io_on_error)
 
     if (close_io_on_error) {
 	int state = 0;
-	new_wrap_arg_t *arg = rb_tr_new_managed_struct(new_wrap_arg_t);
-	arg->argc = argc;
-	arg->argv = argv;
-	arg->klass = klass;
-	obj = rb_protect(new_wrap, (VALUE)arg, &state);
+	new_wrap_arg_t arg;
+	arg.argc = argc;
+	arg.argv = argv;
+	arg.klass = klass;
+	obj = rb_protect(new_wrap, (VALUE)&arg, &state);
 	if (state) {
 	    rb_io_close(argv[0]);
 	    rb_jump_tag(state);

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

@@ -168,6 +168,12 @@ protected ValueWrapper wrappedValueWrapper(ValueWrapper value) {
             return value;
         }
 
+        @Specialization
+        protected ValueWrapper longToWrapper(long value,
+                @Cached NativeToWrapperNode nativeToWrapperNode) {
+            return nativeToWrapperNode.execute(value);
+        }
+
         @Specialization(
                 guards = { "!isWrapper(value)", "values.isPointer(value)" },
                 limit = "getCacheLimit()",
@@ -217,6 +223,12 @@ protected long unwrapValueTaggedLong(ValueWrapper value) {
         return value.getHandle() >> 1;
     }
 
+    @Specialization
+    protected Object longToWrapper(long value,
+            @Cached UnwrapNativeNode unwrapNode) {
+        return unwrapNode.execute(value);
+    }
+
     @Specialization(
             guards = { "!isWrapper(value)", "values.isPointer(value)" },
             limit = "getCacheLimit()",

src/main/java/org/truffleruby/core/MarkerReference.java

@@ -11,14 +11,13 @@
 
 import java.lang.ref.ReferenceQueue;
 
-import com.oracle.truffle.api.object.DynamicObject;
 
-class MarkerReference extends ReferenceProcessingService.WeakProcessingReference<MarkerReference, DynamicObject> {
+class MarkerReference extends ReferenceProcessingService.WeakProcessingReference<MarkerReference, Object> {
 
     final MarkingService.MarkerAction action;
 
     MarkerReference(
-            DynamicObject object,
+            Object object,
             ReferenceQueue<? super Object> queue,
             MarkingService.MarkerAction action,
             MarkingService service) {

src/main/java/org/truffleruby/core/MarkingService.java

@@ -42,7 +42,7 @@
 public class MarkingService extends ReferenceProcessingService<MarkerReference> {
 
     public static interface MarkerAction {
-        public abstract void mark(DynamicObject owner);
+        public abstract void mark(Object owner);
     }
 
     public static class MarkRunnerReference extends WeakProcessingReference<MarkRunnerReference, Object> {
@@ -208,7 +208,7 @@ public void queueMarking() {
         queueForMarking(ValueWrapperManager.HandleBlock.DUMMY_BLOCK);
     }
 
-    public void addMarker(DynamicObject object, MarkerAction action) {
+    public void addMarker(Object object, MarkerAction action) {
         add(new MarkerReference(object, referenceProcessor.processingQueue, action, this));
     }
 
@@ -218,7 +218,7 @@ private void runMarker(MarkerReference markerReference) {
 
     private void runMarkerInternal(MarkerReference markerReference) {
         if (!context.isFinalizing()) {
-            DynamicObject owner = markerReference.get();
+            Object owner = markerReference.get();
             if (owner != null) {
                 final MarkerAction action = markerReference.action;
                 action.mark(owner);

src/main/java/org/truffleruby/core/ReferenceProcessingService.java

@@ -55,9 +55,7 @@ public WeakProcessingReference(
         private void check(R previous, R next) {
 
             if (next != null && next == previous) {
-                Error e = new Error();
-                e.printStackTrace();
-                throw e;
+                throw new Error();
             }
 
         }