[GR-19220] Refactor detect_recursion (#2114)

PullRequest: truffleruby/2072

Author: eregon

lib/truffle/truffle/cext.rb

@@ -1508,7 +1508,7 @@ def rb_rescue2(b_proc, data1, r_proc, data2, rescued)
   def rb_exec_recursive(func, obj, arg)
     result = nil
 
-    recursive = Thread.detect_recursion(obj) do
+    recursive = Truffle::ThreadOperations.detect_recursion(obj) do
       result = Primitive.cext_unwrap(Primitive.call_with_c_mutex(func, [Primitive.cext_wrap(obj), Primitive.cext_wrap(arg), 0]))
     end
 

spec/truffle/thread/detect_recursion_spec.rb

@@ -0,0 +1,249 @@
+# Copyright (c) 2020 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 2.0, or
+# GNU General Public License version 2, or
+# GNU Lesser General Public License version 2.1.
+
+require_relative '../../ruby/spec_helper'
+
+module TruffleThreadDetectRecursionSpecFixtures
+  def self.check_recursion_to_depth(obj, depth)
+    # checks that obj recurses to a given depth
+    return false unless obj.respond_to?(:each)
+    Truffle::ThreadOperations.detect_recursion(obj) do
+      if depth > 1
+        obj.each do |el|
+          if check_recursion_to_depth(el, depth-1)
+            return true
+          end
+        end
+      end
+    end
+  end
+
+  def self.check_double_recursion_equality_to_depth(obj1, obj2, depth)
+    # checks that obj1 and obj2 are both recursive and equal structurally
+    # (because detect_pair_recursion on two objects is only used during object comparison,
+    # and aborts after inequality is discovered)
+    return false unless obj1.class == obj2.class
+    return false unless obj1.respond_to?(:each)
+    return false unless obj1.size == obj2.size
+
+    Truffle::ThreadOperations.detect_pair_recursion(obj1, obj2) do
+      if depth > 1
+        if obj1.class == Hash
+          obj1.each do |key, val|
+            return false unless obj2.has_key?(key)
+            if check_double_recursion_equality_to_depth(val, obj2[key], depth-1)
+              return true
+            end
+          end
+        else
+          obj1.size.times do |i|
+            if check_double_recursion_equality_to_depth(obj1[i], obj2[i], depth-1)
+              return true
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+describe "Thread#detect_recursion" do
+
+  describe "for empty arrays" do
+    it "returns false" do
+      a = []
+      10.times do |i|
+        TruffleThreadDetectRecursionSpecFixtures.check_recursion_to_depth(a, i).should be_false
+      end
+    end
+  end
+
+  describe "for empty hashes" do
+    it "returns false" do
+      a = {}
+      10.times do |i|
+        TruffleThreadDetectRecursionSpecFixtures.check_recursion_to_depth(a, i).should be_false
+      end
+    end
+  end
+
+  describe "for single arrays" do
+    it "for non-recursive arrays returns false" do
+      a = [1,[2,[3], 4],[[[5,6,7]]]]
+
+      10.times do |i|
+        TruffleThreadDetectRecursionSpecFixtures.check_recursion_to_depth(a, i).should be_false
+      end
+    end
+
+    it "for recursive arrays returns true after sufficient depth to detect recursion" do
+      a = []
+      a << [[[a]]]
+
+      b = []
+      b << [1,[2,[3,b],4],5]
+
+      10.times do |i|
+        if i < 5
+          TruffleThreadDetectRecursionSpecFixtures.check_recursion_to_depth(a, i).should be_false
+          TruffleThreadDetectRecursionSpecFixtures.check_recursion_to_depth(b, i).should be_false
+        else
+          TruffleThreadDetectRecursionSpecFixtures.check_recursion_to_depth(a, i).should be_true
+          TruffleThreadDetectRecursionSpecFixtures.check_recursion_to_depth(b, i).should be_true
+        end
+      end
+    end
+  end
+
+  describe "for single hashes" do
+    it "for non-recursive hashes returns false" do
+      a = {:q => {:w => "qwe" }, :t => {:q => {:w => "qwe" }, :t => {:q => {:w => "qwe" }}}}
+
+      10.times do |i|
+        TruffleThreadDetectRecursionSpecFixtures.check_recursion_to_depth(a, i).should be_false
+      end
+    end
+
+    it "for recursive hashes returns true after sufficient depth to detect recursion" do
+      a = {:q => {:w => "qwe" }}
+      a[:t] = a
+
+      10.times do |i|
+        if i < 3
+          TruffleThreadDetectRecursionSpecFixtures.check_recursion_to_depth(a, i).should be_false
+        else
+          TruffleThreadDetectRecursionSpecFixtures.check_recursion_to_depth(a, i).should be_true
+        end
+      end
+    end
+  end
+
+  describe "for single structs" do
+    it "for recursive structs returns true after sufficient depth to detect recursion" do
+      car = Struct.new(:make, :model, :year)
+      a = car.new("Honda", "Accord", "1998")
+      a[:make] = a
+
+      10.times do |i|
+        if i < 2
+          TruffleThreadDetectRecursionSpecFixtures.check_recursion_to_depth(a, i).should be_false
+        else
+          TruffleThreadDetectRecursionSpecFixtures.check_recursion_to_depth(a, i).should be_true
+        end
+      end
+    end
+  end
+
+  describe "for single mixtures of types" do
+    it "for recursive structs returns true after sufficient depth to detect recursion" do
+      car = Struct.new(:make, :model, :year)
+      a = car.new("Honda", "Accord", "1998")
+      a[:make] = [{:car_make => ["a mess", {:here => a}]}]
+
+      10.times do |i|
+        if i < 8
+          TruffleThreadDetectRecursionSpecFixtures.check_recursion_to_depth(a, i).should be_false
+        else
+          TruffleThreadDetectRecursionSpecFixtures.check_recursion_to_depth(a, i).should be_true
+        end
+      end
+    end
+  end
+
+  describe "for a pair of arrays" do
+    it "returns false when structure differs" do
+      a = []
+      a << a
+
+      c = [[[[[[[[[a,1]]]]]]]]]
+
+      10.times do |i|
+        TruffleThreadDetectRecursionSpecFixtures.check_double_recursion_equality_to_depth(a, c, i).should be_false
+      end
+    end
+
+    it "returns true after sufficient depth to detect recursion and equivalent structure" do
+      a = []
+      a << a
+
+      b = []
+      b << [[[[[[b]]]]]]
+
+      10.times do |i|
+        if i < 8
+          TruffleThreadDetectRecursionSpecFixtures.check_double_recursion_equality_to_depth(a, b, i).should be_false
+        else
+          TruffleThreadDetectRecursionSpecFixtures.check_double_recursion_equality_to_depth(a, b, i).should be_true
+        end
+      end
+    end
+  end
+
+  describe "for a pair of hashes" do
+    it "returns false when structure differs" do
+      a = {:q => {:w => "qwe" }}
+      a[:t] = a
+
+      b = {:q => {:w => "qwe" }, :t => {:t => {:w => "qwe" }, :q => a}}
+
+      10.times do |i|
+        TruffleThreadDetectRecursionSpecFixtures.check_double_recursion_equality_to_depth(a, b, i).should be_false
+      end
+    end
+
+    it "returns true after sufficient depth to detect recursion and equivalent structure" do
+      a = {:q => {:w => "qwe" }}
+      a[:t] = a
+
+      b = {:q => {:w => "qwe" }, :t => {:q => {:w => "qwe" }, :t => a}}
+
+      10.times do |i|
+        if i < 4
+          TruffleThreadDetectRecursionSpecFixtures.check_double_recursion_equality_to_depth(a, b, i).should be_false
+        else
+          TruffleThreadDetectRecursionSpecFixtures.check_double_recursion_equality_to_depth(a, b, i).should be_true
+        end
+      end
+    end
+  end
+
+  describe "for a pair of  structs" do
+    it "returns true after sufficient depth to detect recursion and equivalent structure" do
+      car = Struct.new(:make, :model, :year)
+      a = car.new("Honda", "Accord", "1998")
+      a[:make] = a
+      b = car.new(a, "Accord", "1998")
+
+      10.times do |i|
+        if i < 3
+          TruffleThreadDetectRecursionSpecFixtures.check_double_recursion_equality_to_depth(a, b, i).should be_false
+        else
+          TruffleThreadDetectRecursionSpecFixtures.check_double_recursion_equality_to_depth(a, b, i).should be_true
+        end
+      end
+    end
+  end
+
+  describe "for a pair of mixtures of types" do
+    it "returns true after sufficient depth to detect recursion and equivalent structure" do
+      car = Struct.new(:make, :model, :year)
+      a = car.new("Honda", "Accord", "1998")
+      a[:make] = [{:car_make => ["a mess", {:here => a}]}]
+      b = car.new([{:car_make => ["a mess", {:here => a}]}], "Accord", "1998")
+
+      20.times do |i|
+        if i < 11
+          TruffleThreadDetectRecursionSpecFixtures.check_double_recursion_equality_to_depth(a, b, i).should be_false
+        else
+          TruffleThreadDetectRecursionSpecFixtures.check_double_recursion_equality_to_depth(a, b, i).should be_true
+        end
+      end
+    end
+  end
+
+end

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

@@ -1039,6 +1039,7 @@ public boolean isTruffleBootMainMethod(SharedMethodInfo info) {
             "/core/truffle/exception_operations.rb",
             "/core/truffle/feature_loader.rb",
             "/core/truffle/gem_util.rb",
+            "/core/truffle/thread_operations.rb",
             "/core/thread.rb",
             "/core/true.rb",
             "/core/type.rb",

src/main/ruby/truffleruby/core/array.rb

@@ -89,7 +89,7 @@ def <=>(other)
 
     total = other.size
 
-    Thread.detect_recursion self, other do
+    Truffle::ThreadOperations.detect_pair_recursion self, other do
       i = 0
       count = Primitive.min(total, size)
 
@@ -132,7 +132,7 @@ def ==(other)
 
     return false unless size == other.size
 
-    Thread.detect_recursion self, other do
+    Truffle::ThreadOperations.detect_pair_recursion self, other do
       i = 0
       total = size
 
@@ -325,7 +325,7 @@ def eql?(other)
     return false unless other.kind_of?(Array)
     return false if size != other.size
 
-    Thread.detect_recursion self, other do
+    Truffle::ThreadOperations.detect_pair_recursion self, other do
       i = 0
       each do |x|
         return false unless x.eql? other[i]
@@ -484,7 +484,7 @@ def hash
 
       # If we've seen self, unwind back to the outer version
       if objects.key? id
-        raise Thread::InnerRecursionDetected
+        raise Truffle::ThreadOperations::InnerRecursionDetected
       end
 
       # .. or compute the hash value like normal
@@ -508,7 +508,7 @@ def hash
         # An inner version will raise to return back here, indicating that
         # the whole structure is recursive. In which case, abandon most of
         # the work and return a simple hash value.
-      rescue Thread::InnerRecursionDetected
+      rescue Truffle::ThreadOperations::InnerRecursionDetected
         return size
       ensure
         objects.delete :__detect_outermost_recursion__
@@ -549,7 +549,7 @@ def inspect
     comma = ', '
     result = +'['
 
-    return +'[...]' if Thread.detect_recursion self do
+    return +'[...]' if Truffle::ThreadOperations.detect_recursion self do
       each_with_index do |element, index|
         temp = Truffle::Type.rb_inspect(element)
         result.force_encoding(temp.encoding) if index == 0
@@ -568,7 +568,7 @@ def join(sep=nil)
     return ''.encode(Encoding::US_ASCII) if size == 0
 
     out = +''
-    raise ArgumentError, 'recursive array join' if Thread.detect_recursion self do
+    raise ArgumentError, 'recursive array join' if Truffle::ThreadOperations.detect_recursion self do
       sep = Primitive.nil?(sep) ? $, : StringValue(sep)
 
       # We've manually unwound the first loop entry for performance
@@ -1263,7 +1263,7 @@ def recursively_flatten(array, out, max_levels = -1)
     end
 
     max_levels -= 1
-    recursion = Thread.detect_recursion(array) do
+    recursion = Truffle::ThreadOperations.detect_recursion(array) do
       array = Truffle::Type.coerce_to(array, Array, :to_ary)
 
       i = 0

src/main/ruby/truffleruby/core/comparable.rb

@@ -30,7 +30,7 @@ module Comparable
   def ==(other)
     return true if equal?(other)
 
-    return false if Thread.detect_recursion(self, other) do
+    return false if Truffle::ThreadOperations.detect_pair_recursion(self, other) do
       unless comp = (self <=> other)
         return false
       end

src/main/ruby/truffleruby/core/enumerator.rb

@@ -704,7 +704,7 @@ def rewind
   end
 
   def inspect
-    return "#<#{self.class.name}: ...>" if Thread.detect_recursion(self) do
+    return "#<#{self.class.name}: ...>" if Truffle::ThreadOperations.detect_recursion(self) do
       return "#<#{self.class.name}: #{@enums}>"
     end
   end

src/main/ruby/truffleruby/core/file.rb

@@ -733,7 +733,7 @@ def self.join(*args)
     when String
       first = first.dup
     when Array
-      recursion = Thread.detect_recursion(first) do
+      recursion = Truffle::ThreadOperations.detect_recursion(first) do
         first = join(*first)
       end
 
@@ -754,7 +754,7 @@ def self.join(*args)
       when String
         value = el
       when Array
-        recursion = Thread.detect_recursion(el) do
+        recursion = Truffle::ThreadOperations.detect_recursion(el) do
           value = join(*el)
         end