concurrent-ruby 1.0.5 → 1.1.1

data/Rakefile

@@ -0,0 +1,314 @@
+#!/usr/bin/env rake
+
+require_relative 'lib/concurrent/version'
+require_relative 'lib/concurrent/utility/engine'
+require_relative 'lib/concurrent/utility/193'
+
+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')
+
+require 'rake/javaextensiontask'
+
+JRUBY_JAR_PATH = '/usr/local/opt/rbenv/versions/jruby-9.1.17.0/lib/jruby.jar'
+
+class ConcurrentRubyJavaExtensionTask < Rake::JavaExtensionTask
+  def java_classpath_arg(*args)
+    jruby_cpath = nil
+    if RUBY_PLATFORM =~ /java/
+      begin
+        cpath       = Java::java.lang.System.getProperty('java.class.path').split(File::PATH_SEPARATOR)
+        cpath       += Java::java.lang.System.getProperty('sun.boot.class.path').split(File::PATH_SEPARATOR)
+        jruby_cpath = cpath.compact.join(File::PATH_SEPARATOR)
+      rescue => e
+      end
+    end
+    unless jruby_cpath
+      jruby_cpath = JRUBY_JAR_PATH
+      raise "#{jruby_cpath} does not exist" unless File.exist? jruby_cpath
+    end
+    jruby_cpath += File::PATH_SEPARATOR + args.join(File::PATH_SEPARATOR) unless args.empty?
+    jruby_cpath ? "-cp \"#{jruby_cpath}\"" : ""
+  end
+end
+
+ConcurrentRubyJavaExtensionTask.new('concurrent_ruby', core_gemspec) do |ext|
+  ext.ext_dir = 'ext/concurrent-ruby'
+  ext.lib_dir = 'lib/concurrent'
+end
+
+unless Concurrent.on_jruby?
+  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'
+    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
+      sh 'bundle package'
+      # needed only if the jar is built outside of docker
+      Rake::Task['lib/concurrent/concurrent_ruby.jar'].invoke
+      RakeCompilerDock.exec 'support/cross_building.sh'
+    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/2.*', 'lib/concurrent/*.jar')
+
+begin
+  require 'rspec'
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+
+  options = %w[ --color
+                --backtrace
+                --seed 1
+                --format documentation
+                --tag ~notravis ]
+
+  namespace :spec do
+    desc '* Configured for ci'
+    RSpec::Core::RakeTask.new(:ci) do |t|
+      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.split('.')[0..2].join('.')
+
+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
+      desc "* of #{name} into subdir #{name}"
+      YARD::Rake::YardocTask.new(name) do |yard|
+        yard.options.push(
+            '--output-dir', "docs/#{name}",
+            '--main', 'tmp/README.md',
+            *common_yard_options)
+        yard.files = ['./lib/**/*.rb',
+                      './lib-edge/**/*.rb',
+                      './ext/concurrent_ruby_ext/**/*.c',
+                      '-',
+                      'docs-source/thread_pools.md',
+                      'docs-source/promises.out.md',
+                      'LICENSE.md',
+                      'CHANGELOG.md']
+      end
+      Rake::Task[name].prerequisites.push '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/'
+            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
+
+  mri_version   = '2.5.1'
+  jruby_version = 'jruby-9.1.17.1'
+
+  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
+            STDOUT.puts 'Command failed. 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 'Command failed. 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 => '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']
+
+      ENV['RBENV_VERSION'] = mri_version
+      sh 'rbenv version'
+      sh 'bundle exec rake spec:installed'
+
+      ENV['RBENV_VERSION'] = jruby_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
+    task :ask do
+      begin
+        STDOUT.puts 'Do you want to publish? (y/n)'
+        input = STDIN.gets.strip.downcase
+      end until %w(y n).include?(input)
+      exit 1 if input == 'n'
+    end
+
+    desc '** tag HEAD with current version and push to github'
+    task :tag do
+      Dir.chdir(__dir__) do
+        sh "git tag v#{Concurrent::VERSION}"
+        sh "git tag edge-v#{Concurrent::EDGE_VERSION}"
+        sh "git push origin v#{Concurrent::VERSION} edge-v#{Concurrent::EDGE_VERSION}"
+      end
+    end
+
+    desc '** push all *.gem files to rubygems'
+    task :rubygems 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"
+        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
+      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);
+        }
+    }
+}