o-concurrent-ruby 1.1.11

data/Rakefile

@@ -0,0 +1,307 @@
+require_relative 'lib/concurrent-ruby/concurrent/version'
+require_relative 'lib/concurrent-ruby-edge/concurrent/edge/version'
+require_relative 'lib/concurrent-ruby/concurrent/utility/engine'
+
+core_gemspec = Gem::Specification.load File.join(__dir__, 'concurrent-ruby.gemspec')
+ext_gemspec  = Gem::Specification.load File.join(__dir__, 'concurrent-ruby-ext.gemspec')
+edge_gemspec = Gem::Specification.load File.join(__dir__, 'concurrent-ruby-edge.gemspec')
+
+unless Concurrent.on_jruby? || Concurrent.on_truffleruby?
+  require 'rake/extensiontask'
+
+  Rake::ExtensionTask.new('concurrent_ruby_ext', ext_gemspec) do |ext|
+    ext.ext_dir        = 'ext/concurrent-ruby-ext'
+    ext.lib_dir        = 'lib/concurrent-ruby/concurrent'
+    ext.source_pattern = '*.{c,h}'
+
+    ext.cross_compile  = true
+    ext.cross_platform = ['x86-mingw32', 'x64-mingw32']
+  end
+end
+
+require 'rake_compiler_dock'
+namespace :repackage do
+  desc '* with Windows fat distributions'
+  task :all do
+    Dir.chdir(__dir__) do
+      # store gems in vendor cache for docker
+      sh 'bundle package'
+    end
+  end
+end
+
+require 'rubygems'
+require 'rubygems/package_task'
+
+Gem::PackageTask.new(core_gemspec) {} if core_gemspec
+Gem::PackageTask.new(ext_gemspec) {} if ext_gemspec && !Concurrent.on_jruby?
+Gem::PackageTask.new(edge_gemspec) {} if edge_gemspec
+
+CLEAN.include('lib/concurrent-ruby/concurrent/2.*')
+
+begin
+  require 'rspec'
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+
+  namespace :spec do
+    desc '* Configured for ci'
+    RSpec::Core::RakeTask.new(:ci) do |t|
+      options      = %w[ --color
+                    --backtrace
+                    --order defined
+                    --format documentation ]
+      t.rspec_opts = [*options].join(' ')
+    end
+
+    desc '* test packaged and installed gems instead of local files'
+    task :installed do
+      Dir.chdir(__dir__) do
+        sh "gem install pkg/concurrent-ruby-#{Concurrent::VERSION}.gem"
+        sh "gem install pkg/concurrent-ruby-ext-#{Concurrent::VERSION}.gem" if Concurrent.on_cruby?
+        sh "gem install pkg/concurrent-ruby-edge-#{Concurrent::EDGE_VERSION}.gem"
+        ENV['NO_PATH'] = 'true'
+        sh 'bundle update'
+        sh 'bundle exec rake spec:ci'
+      end
+    end
+  end
+
+  desc 'executed in CI'
+  task :ci => [:compile, 'spec:ci']
+
+  task :default => [:clobber, :compile, :spec]
+rescue LoadError => e
+  puts 'RSpec is not installed, skipping test task definitions: ' + e.message
+end
+
+current_yard_version_name = Concurrent::VERSION
+
+begin
+  require 'yard'
+  require 'md_ruby_eval'
+  require_relative 'support/yard_full_types'
+
+  common_yard_options = ['--no-yardopts',
+                         '--no-document',
+                         '--no-private',
+                         '--embed-mixins',
+                         '--markup', 'markdown',
+                         '--title', 'Concurrent Ruby',
+                         '--template', 'default',
+                         '--template-path', 'yard-template',
+                         '--default-return', 'undocumented']
+
+  desc 'Generate YARD Documentation (signpost, master)'
+  task :yard => ['yard:signpost', 'yard:master']
+
+  namespace :yard do
+
+    desc '* eval markdown files'
+    task :eval_md do
+      Dir.chdir File.join(__dir__, 'docs-source') do
+        sh 'bundle exec md-ruby-eval --auto'
+      end
+    end
+
+    task :update_readme do
+      Dir.chdir __dir__ do
+        content = File.read(File.join('README.md')).
+          gsub(/\[([\w ]+)\]\(http:\/\/ruby-concurrency\.github\.io\/concurrent-ruby\/master\/.*\)/) do |_|
+          case $1
+          when 'LockFreeLinkedSet'
+            "{Concurrent::Edge::#{$1} #{$1}}"
+          when '.dataflow'
+            '{Concurrent.dataflow Concurrent.dataflow}'
+          when 'thread pool'
+            '{file:thread_pools.md thread pool}'
+          else
+            "{Concurrent::#{$1} #{$1}}"
+          end
+        end
+        FileUtils.mkpath 'tmp'
+        File.write 'tmp/README.md', content
+      end
+    end
+
+    define_yard_task = -> name do
+      output_dir = "docs/#{name}"
+
+      removal_name = "remove.#{name}"
+      task removal_name do
+        Dir.chdir __dir__ do
+          FileUtils.rm_rf output_dir
+        end
+      end
+
+      desc "* of #{name} into subdir #{name}"
+      YARD::Rake::YardocTask.new(name) do |yard|
+        yard.options.push(
+          '--output-dir', output_dir,
+          '--main', 'tmp/README.md',
+          *common_yard_options)
+        yard.files = ['./lib/concurrent-ruby/**/*.rb',
+                      './lib/concurrent-ruby-edge/**/*.rb',
+                      './ext/concurrent_ruby_ext/**/*.c',
+                      '-',
+                      'docs-source/thread_pools.md',
+                      'docs-source/promises.out.md',
+                      'docs-source/medium-example.out.rb',
+                      'LICENSE.txt',
+                      'CHANGELOG.md']
+      end
+      Rake::Task[name].prerequisites.push removal_name,
+                                          # 'yard:eval_md',
+                                          'yard:update_readme'
+    end
+
+    define_yard_task.call current_yard_version_name
+    define_yard_task.call 'master'
+
+    desc "* signpost for versions"
+    YARD::Rake::YardocTask.new(:signpost) do |yard|
+      yard.options.push(
+        '--output-dir', 'docs',
+        '--main', 'docs-source/signpost.md',
+        *common_yard_options)
+      yard.files = ['no-lib']
+    end
+
+    define_uptodate_task = -> name do
+      namespace name do
+        desc "** ensure that #{name} generated documentation is matching the source code"
+        task :uptodate do
+          Dir.chdir(__dir__) do
+            begin
+              FileUtils.cp_r 'docs', 'docs-copy', verbose: true
+              Rake::Task["yard:#{name}"].invoke
+              sh 'diff -r docs/ docs-copy/' do |ok, res|
+                unless ok
+                  begin
+                    STDOUT.puts "yard:#{name} is not properly generated and committed.", "Continue? (y/n)"
+                    input = STDIN.gets.strip.downcase
+                  end until %w(y n).include?(input)
+                  exit 1 if input == 'n'
+                end
+              end
+            ensure
+              FileUtils.rm_rf 'docs-copy', verbose: true
+            end
+          end
+        end
+      end
+    end
+
+    define_uptodate_task.call current_yard_version_name
+    define_uptodate_task.call 'master'
+  end
+
+rescue LoadError => e
+  puts 'YARD is not installed, skipping documentation task definitions: ' + e.message
+end
+
+desc 'build, test, and publish the gem'
+task :release => ['release:checks', 'release:build', 'release:test', 'release:publish']
+
+namespace :release do
+  # Depends on environment of @pitr-ch
+
+  task :checks => "yard:#{current_yard_version_name}:uptodate" do
+    Dir.chdir(__dir__) do
+      sh 'test -z "$(git status --porcelain)"' do |ok, res|
+        unless ok
+          begin
+            status = `git status --porcelain`
+            STDOUT.puts 'There are local changes that you might want to commit.', status, 'Continue? (y/n)'
+            input = STDIN.gets.strip.downcase
+          end until %w(y n).include?(input)
+          exit 1 if input == 'n'
+        end
+      end
+      sh 'git fetch'
+      sh 'test $(git show-ref --verify --hash refs/heads/master) = ' +
+           '$(git show-ref --verify --hash refs/remotes/origin/master)' do |ok, res|
+        unless ok
+          begin
+            STDOUT.puts 'Local master branch is not pushed to origin.', 'Continue? (y/n)'
+            input = STDIN.gets.strip.downcase
+          end until %w(y n).include?(input)
+          exit 1 if input == 'n'
+        end
+      end
+    end
+  end
+
+  desc '* build all *.gem files necessary for release'
+  task :build => [:clobber, 'repackage:all']
+
+  desc '* test actual installed gems instead of cloned repository on MRI and JRuby'
+  task :test do
+    Dir.chdir(__dir__) do
+      old = ENV['RBENV_VERSION']
+
+      mri_version   = `ruby -e 'puts RUBY_VERSION'`.chomp
+
+      puts "Using following version:"
+      pp mri_version: mri_version
+
+      ENV['RBENV_VERSION'] = mri_version
+      sh 'rbenv version'
+      sh 'bundle exec rake spec:installed'
+
+      puts 'Windows build is untested'
+
+      ENV['RBENV_VERSION'] = old
+    end
+  end
+
+  desc '* do all nested steps'
+  task :publish => ['publish:ask', 'publish:tag', 'publish:rubygems', 'publish:post_steps']
+
+  namespace :publish do
+    publish_edge = false
+
+    task :ask do
+      begin
+        STDOUT.puts 'Do you want to publish anything now? (y/n)'
+        input = STDIN.gets.strip.downcase
+      end until %w(y n).include?(input)
+      exit 1 if input == 'n'
+      begin
+        STDOUT.puts 'It will publish `concurrent-ruby`. Do you want to publish `concurrent-ruby-edge`? (y/n)'
+        input = STDIN.gets.strip.downcase
+      end until %w(y n).include?(input)
+      publish_edge = input == 'y'
+    end
+
+    desc '** tag HEAD with current version and push to github'
+    task :tag => :ask do
+      Dir.chdir(__dir__) do
+        sh "git tag v#{Concurrent::VERSION}"
+        sh "git push origin v#{Concurrent::VERSION}"
+        sh "git tag edge-v#{Concurrent::EDGE_VERSION}" if publish_edge
+        sh "git push origin edge-v#{Concurrent::EDGE_VERSION}" if publish_edge
+      end
+    end
+
+    desc '** push all *.gem files to rubygems'
+    task :rubygems => :ask do
+      Dir.chdir(__dir__) do
+        sh "gem push pkg/concurrent-ruby-#{Concurrent::VERSION}.gem"
+        sh "gem push pkg/concurrent-ruby-edge-#{Concurrent::EDGE_VERSION}.gem" if publish_edge
+        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}.gem"
+        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}-x64-mingw32.gem"
+        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}-x86-mingw32.gem"
+      end
+    end
+
+    desc '** print post release steps'
+    task :post_steps do
+      # TODO: (petr 05-Jun-2021) automate and renew the process
+      # puts 'Manually: create a release on GitHub with relevant changelog part'
+      # puts 'Manually: send email same as release with relevant changelog part'
+      # puts 'Manually: tweet'
+    end
+  end
+end

data/ext/concurrent-ruby/ConcurrentRubyService.java

@@ -0,0 +1,17 @@
+import org.jruby.Ruby;
+import org.jruby.runtime.load.BasicLibraryService;
+
+import java.io.IOException;
+
+public class ConcurrentRubyService implements BasicLibraryService {
+
+    public boolean basicLoad(final Ruby runtime) throws IOException {
+        new com.concurrent_ruby.ext.AtomicReferenceLibrary().load(runtime, false);
+        new com.concurrent_ruby.ext.JavaAtomicBooleanLibrary().load(runtime, false);
+        new com.concurrent_ruby.ext.JavaAtomicFixnumLibrary().load(runtime, false);
+        new com.concurrent_ruby.ext.JavaSemaphoreLibrary().load(runtime, false);
+        new com.concurrent_ruby.ext.SynchronizationLibrary().load(runtime, false);
+        new com.concurrent_ruby.ext.JRubyMapBackendLibrary().load(runtime, false);
+        return true;
+    }
+}

data/ext/concurrent-ruby/com/concurrent_ruby/ext/AtomicReferenceLibrary.java

@@ -0,0 +1,175 @@
+package com.concurrent_ruby.ext;
+
+import java.lang.reflect.Field;
+import java.io.IOException;
+import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.Library;
+
+/**
+ * This library adds an atomic reference type to JRuby for use in the atomic
+ * library. We do a native version to avoid the implicit value coercion that
+ * normally happens through JI.
+ * 
+ * @author headius
+ */
+public class AtomicReferenceLibrary implements Library {
+    public void load(Ruby runtime, boolean wrap) throws IOException {
+        RubyModule concurrentMod = runtime.defineModule("Concurrent");
+        RubyClass atomicCls = concurrentMod.defineClassUnder("JavaAtomicReference", runtime.getObject(), JRUBYREFERENCE_ALLOCATOR);
+        try {
+            sun.misc.Unsafe.class.getMethod("getAndSetObject", Object.class);
+            atomicCls.setAllocator(JRUBYREFERENCE8_ALLOCATOR);
+        } catch (Exception e) {
+            // leave it as Java 6/7 version
+        }
+        atomicCls.defineAnnotatedMethods(JRubyReference.class);
+    }
+    
+    private static final ObjectAllocator JRUBYREFERENCE_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new JRubyReference(runtime, klazz);
+        }
+    };
+    
+    private static final ObjectAllocator JRUBYREFERENCE8_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new JRubyReference8(runtime, klazz);
+        }
+    };
+
+    @JRubyClass(name="JRubyReference", parent="Object")
+    public static class JRubyReference extends RubyObject {
+        volatile IRubyObject reference;
+        
+        static final sun.misc.Unsafe UNSAFE;
+        static final long referenceOffset;
+
+        static {
+            try {
+                UNSAFE = UnsafeHolder.U;
+                Class k = JRubyReference.class;
+                referenceOffset = UNSAFE.objectFieldOffset(k.getDeclaredField("reference"));
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        public JRubyReference(Ruby runtime, RubyClass klass) {
+            super(runtime, klass);
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context) {
+            UNSAFE.putObject(this, referenceOffset, context.nil);
+            return context.nil;
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context, IRubyObject value) {
+            UNSAFE.putObject(this, referenceOffset, value);
+            return context.nil;
+        }
+
+        @JRubyMethod(name = {"get", "value"})
+        public IRubyObject get() {
+            return reference;
+        }
+
+        @JRubyMethod(name = {"set", "value="})
+        public IRubyObject set(IRubyObject newValue) {
+            UNSAFE.putObjectVolatile(this, referenceOffset, newValue);
+            return newValue;
+        }
+
+        @JRubyMethod(name = {"compare_and_set", "compare_and_swap"})
+        public IRubyObject compare_and_set(ThreadContext context, IRubyObject expectedValue, IRubyObject newValue) {
+            Ruby runtime = context.runtime;
+            
+            if (expectedValue instanceof RubyNumeric) {
+                // numerics are not always idempotent in Ruby, so we need to do slower logic
+                return compareAndSetNumeric(context, expectedValue, newValue);
+            }
+            
+            return runtime.newBoolean(UNSAFE.compareAndSwapObject(this, referenceOffset, expectedValue, newValue));
+        }
+
+        @JRubyMethod(name = {"get_and_set", "swap"})
+        public IRubyObject get_and_set(ThreadContext context, IRubyObject newValue) {
+            // less-efficient version for Java 6 and 7
+            while (true) {
+                IRubyObject oldValue = get();
+                if (UNSAFE.compareAndSwapObject(this, referenceOffset, oldValue, newValue)) {
+                    return oldValue;
+                }
+            }
+        }
+        
+        private IRubyObject compareAndSetNumeric(ThreadContext context, IRubyObject expectedValue, IRubyObject newValue) {
+            Ruby runtime = context.runtime;
+            
+            // loop until:
+            // * reference CAS would succeed for same-valued objects
+            // * current and expected have different values as determined by #equals
+            while (true) {
+                IRubyObject current = reference;
+
+                if (!(current instanceof RubyNumeric)) {
+                    // old value is not numeric, CAS fails
+                    return runtime.getFalse();
+                }
+
+                RubyNumeric currentNumber = (RubyNumeric)current;
+                if (!currentNumber.equals(expectedValue)) {
+                    // current number does not equal expected, fail CAS
+                    return runtime.getFalse();
+                }
+
+                // check that current has not changed, or else allow loop to repeat
+                boolean success = UNSAFE.compareAndSwapObject(this, referenceOffset, current, newValue);
+                if (success) {
+                    // value is same and did not change in interim...success
+                    return runtime.getTrue();
+                }
+            }
+        }
+    }
+
+    private static final class UnsafeHolder {
+	private UnsafeHolder(){}
+	    
+	public static final sun.misc.Unsafe U = loadUnsafe();
+	
+	private static sun.misc.Unsafe loadUnsafe() {
+	    try {
+		Class unsafeClass = Class.forName("sun.misc.Unsafe");
+		Field f = unsafeClass.getDeclaredField("theUnsafe");
+		f.setAccessible(true);
+		return (sun.misc.Unsafe) f.get(null);
+	    } catch (Exception e) {
+		return null;
+	    }
+	}
+    }
+    
+    public static class JRubyReference8 extends JRubyReference {
+        public JRubyReference8(Ruby runtime, RubyClass klass) {
+            super(runtime, klass);
+        }
+
+        @Override
+        public IRubyObject get_and_set(ThreadContext context, IRubyObject newValue) {
+            // efficient version for Java 8
+            return (IRubyObject)UNSAFE.getAndSetObject(this, referenceOffset, newValue);
+        }
+    }
+}