sync 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 13600706b4c699e1cf55a80d5174a08031e315d1a3ab85173e5abb2a3b89509c
+  data.tar.gz: 07ff82e89aed6824cab4c1a152bab3c5ccfaf28ac6d944ef5414e65165f09a94
+SHA512:
+  metadata.gz: 1db1886f07e25ec4f2f79c2083303552a856386e1e79bf282fee9d0d7adeb9b155614bcc208fb179d5cc87b4d14f16589f9341b08b2e0f88282bf8c0ab399626
+  data.tar.gz: 24f07556ac43c9dc3626019f5bdab0ceed03add58eb7e911d907abcef8f19f9408bea92181b9c61afea0a369d7ba0cdce61279c081cb2c3bc44e2fcaa8d14b3f

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.6.0
+before_install: gem install bundler -v 1.16.2

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/README.md

@@ -0,0 +1,77 @@
+# Sync
+
+A module that provides a two-phase lock with a counter.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sync'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sync
+
+## Usage
+
+### Sync_m, Synchronizer_m
+
+```
+obj.extend(Sync_m)
+```
+
+or
+
+```
+class Foo
+    include Sync_m
+    :
+end
+```
+
+```
+Sync_m#sync_mode
+Sync_m#sync_locked?, locked?
+Sync_m#sync_shared?, shared?
+Sync_m#sync_exclusive?, sync_exclusive?
+Sync_m#sync_try_lock, try_lock
+Sync_m#sync_lock, lock
+Sync_m#sync_unlock, unlock
+```
+
+### Sync, Synchronizer:
+
+```
+sync = Sync.new
+```
+
+```
+Sync#mode
+Sync#locked?
+Sync#shared?
+Sync#exclusive?
+Sync#try_lock(mode) -- mode = :EX, :SH, :UN
+Sync#lock(mode)     -- mode = :EX, :SH, :UN
+Sync#unlock
+Sync#synchronize(mode) {...}
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/sync.
+
+## License
+
+The gem is available as open source under the terms of the [2-Clause BSD License](https://opensource.org/licenses/BSD-2-Clause).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require_relative "../lib/sync"
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/lib/sync.rb

@@ -0,0 +1,328 @@
+# frozen_string_literal: false
+#
+#   sync.rb - 2 phase lock with counter
+#       $Release Version: 1.0$
+#       $Revision$
+#       by Keiju ISHITSUKA(keiju@ishitsuka.com)
+#
+# --
+#  Sync_m, Synchronizer_m
+#  Usage:
+#   obj.extend(Sync_m)
+#   or
+#   class Foo
+#       include Sync_m
+#       :
+#   end
+#
+#   Sync_m#sync_mode
+#   Sync_m#sync_locked?, locked?
+#   Sync_m#sync_shared?, shared?
+#   Sync_m#sync_exclusive?, sync_exclusive?
+#   Sync_m#sync_try_lock, try_lock
+#   Sync_m#sync_lock, lock
+#   Sync_m#sync_unlock, unlock
+#
+#  Sync, Synchronizer:
+#  Usage:
+#   sync = Sync.new
+#
+#   Sync#mode
+#   Sync#locked?
+#   Sync#shared?
+#   Sync#exclusive?
+#   Sync#try_lock(mode) -- mode = :EX, :SH, :UN
+#   Sync#lock(mode)     -- mode = :EX, :SH, :UN
+#   Sync#unlock
+#   Sync#synchronize(mode) {...}
+#
+#
+
+##
+# A module that provides a two-phase lock with a counter.
+
+module Sync_m
+  # lock mode
+  UN = :UN
+  SH = :SH
+  EX = :EX
+
+  # exceptions
+  class Err < StandardError
+    def Err.Fail(*opt)
+      fail self, sprintf(self::Message, *opt)
+    end
+
+    class UnknownLocker < Err
+      Message = "Thread(%s) not locked."
+      def UnknownLocker.Fail(th)
+        super(th.inspect)
+      end
+    end
+
+    class LockModeFailer < Err
+      Message = "Unknown lock mode(%s)"
+      def LockModeFailer.Fail(mode)
+        if mode.id2name
+          mode = mode.id2name
+        end
+        super(mode)
+      end
+    end
+  end
+
+  def Sync_m.define_aliases(cl)
+    cl.module_eval %q{
+      alias locked? sync_locked?
+      alias shared? sync_shared?
+      alias exclusive? sync_exclusive?
+      alias lock sync_lock
+      alias unlock sync_unlock
+      alias try_lock sync_try_lock
+      alias synchronize sync_synchronize
+    }
+  end
+
+  def Sync_m.append_features(cl)
+    super
+    # do nothing for Modules
+    # make aliases for Classes.
+    define_aliases(cl) unless cl.instance_of?(Module)
+    self
+  end
+
+  def Sync_m.extend_object(obj)
+    super
+    obj.sync_extend
+  end
+
+  def sync_extend
+    unless (defined? locked? and
+            defined? shared? and
+            defined? exclusive? and
+            defined? lock and
+            defined? unlock and
+            defined? try_lock and
+            defined? synchronize)
+      Sync_m.define_aliases(singleton_class)
+    end
+    sync_initialize
+  end
+
+  # accessing
+  def sync_locked?
+    sync_mode != UN
+  end
+
+  def sync_shared?
+    sync_mode == SH
+  end
+
+  def sync_exclusive?
+    sync_mode == EX
+  end
+
+  # locking methods.
+  def sync_try_lock(mode = EX)
+    return unlock if mode == UN
+    @sync_mutex.synchronize do
+      sync_try_lock_sub(mode)
+    end
+  end
+
+  def sync_lock(m = EX)
+    return unlock if m == UN
+    Thread.handle_interrupt(StandardError => :on_blocking) do
+      while true
+        @sync_mutex.synchronize do
+          begin
+            if sync_try_lock_sub(m)
+              return self
+            else
+              if sync_sh_locker[Thread.current]
+                sync_upgrade_waiting.push [Thread.current, sync_sh_locker[Thread.current]]
+                sync_sh_locker.delete(Thread.current)
+              else
+                unless sync_waiting.include?(Thread.current) || sync_upgrade_waiting.reverse_each.any?{|w| w.first == Thread.current }
+                  sync_waiting.push Thread.current
+                end
+              end
+              @sync_mutex.sleep
+            end
+          ensure
+            sync_waiting.delete(Thread.current)
+          end
+        end
+      end
+    end
+    self
+  end
+
+  def sync_unlock(m = EX)
+    wakeup_threads = []
+    @sync_mutex.synchronize do
+      if sync_mode == UN
+        Err::UnknownLocker.Fail(Thread.current)
+      end
+
+      m = sync_mode if m == EX and sync_mode == SH
+
+      runnable = false
+      case m
+      when UN
+        Err::UnknownLocker.Fail(Thread.current)
+
+      when EX
+        if sync_ex_locker == Thread.current
+          if (self.sync_ex_count = sync_ex_count - 1) == 0
+            self.sync_ex_locker = nil
+            if sync_sh_locker.include?(Thread.current)
+              self.sync_mode = SH
+            else
+              self.sync_mode = UN
+            end
+            runnable = true
+          end
+        else
+          Err::UnknownLocker.Fail(Thread.current)
+        end
+
+      when SH
+        if (count = sync_sh_locker[Thread.current]).nil?
+          Err::UnknownLocker.Fail(Thread.current)
+        else
+          if (sync_sh_locker[Thread.current] = count - 1) == 0
+            sync_sh_locker.delete(Thread.current)
+            if sync_sh_locker.empty? and sync_ex_count == 0
+              self.sync_mode = UN
+              runnable = true
+            end
+          end
+        end
+      end
+
+      if runnable
+        if sync_upgrade_waiting.size > 0
+          th, count = sync_upgrade_waiting.shift
+          sync_sh_locker[th] = count
+          th.wakeup
+          wakeup_threads.push th
+        else
+          wait = sync_waiting
+          self.sync_waiting = []
+          for th in wait
+            th.wakeup
+            wakeup_threads.push th
+          end
+        end
+      end
+    end
+    for th in wakeup_threads
+      th.run
+    end
+    self
+  end
+
+  def sync_synchronize(mode = EX)
+    Thread.handle_interrupt(StandardError => :on_blocking) do
+      sync_lock(mode)
+      begin
+        yield
+      ensure
+        sync_unlock
+      end
+    end
+  end
+
+  attr_accessor :sync_mode
+
+  attr_accessor :sync_waiting
+  attr_accessor :sync_upgrade_waiting
+  attr_accessor :sync_sh_locker
+  attr_accessor :sync_ex_locker
+  attr_accessor :sync_ex_count
+
+  def sync_inspect
+    sync_iv = instance_variables.select{|iv| /^@sync_/ =~ iv.id2name}.collect{|iv| iv.id2name + '=' + instance_eval(iv.id2name).inspect}.join(",")
+    print "<#{self.class}.extend Sync_m: #{inspect}, <Sync_m: #{sync_iv}>"
+  end
+
+  private
+
+  def sync_initialize
+    @sync_mode = UN
+    @sync_waiting = []
+    @sync_upgrade_waiting = []
+    @sync_sh_locker = Hash.new
+    @sync_ex_locker = nil
+    @sync_ex_count = 0
+
+    @sync_mutex = Thread::Mutex.new
+  end
+
+  def initialize(*args)
+    super
+    sync_initialize
+  end
+
+  def sync_try_lock_sub(m)
+    case m
+    when SH
+      case sync_mode
+      when UN
+        self.sync_mode = m
+        sync_sh_locker[Thread.current] = 1
+        ret = true
+      when SH
+        count = 0 unless count = sync_sh_locker[Thread.current]
+        sync_sh_locker[Thread.current] = count + 1
+        ret = true
+      when EX
+        # in EX mode, lock will upgrade to EX lock
+        if sync_ex_locker == Thread.current
+          self.sync_ex_count = sync_ex_count + 1
+          ret = true
+        else
+          ret = false
+        end
+      end
+    when EX
+      if sync_mode == UN or
+          sync_mode == SH && sync_sh_locker.size == 1 && sync_sh_locker.include?(Thread.current)
+        self.sync_mode = m
+        self.sync_ex_locker = Thread.current
+        self.sync_ex_count = 1
+        ret = true
+      elsif sync_mode == EX && sync_ex_locker == Thread.current
+        self.sync_ex_count = sync_ex_count + 1
+        ret = true
+      else
+        ret = false
+      end
+    else
+      Err::LockModeFailer.Fail m
+    end
+    return ret
+  end
+end
+
+##
+# An alias for Sync_m from sync.rb
+
+Synchronizer_m = Sync_m
+
+##
+# A class that provides two-phase lock with a counter.  See Sync_m for
+# details.
+
+class Sync
+
+  VERSION = "0.5.0"
+
+  include Sync_m
+end
+
+##
+# An alias for Sync from sync.rb.  See Sync_m for details.
+
+Synchronizer = Sync

data/sync.gemspec

@@ -0,0 +1,27 @@
+begin
+  require_relative "lib/sync"
+rescue LoadError
+  # for Ruby core repository
+  require_relative "sync"
+end
+
+Gem::Specification.new do |spec|
+  spec.name          = "sync"
+  spec.version       = Sync::VERSION
+  spec.authors       = ["Keiju ISHITSUKA"]
+  spec.email         = ["keiju@ruby-lang.org"]
+
+  spec.summary       = %q{A module that provides a two-phase lock with a counter.}
+  spec.description   = %q{A module that provides a two-phase lock with a counter.}
+  spec.homepage      = "https://github.com/ruby/sync"
+  spec.license       = "BSD-2-Clause"
+
+  spec.files         = [".gitignore", ".travis.yml", "Gemfile", "LICENSE.txt", "README.md", "Rakefile", "bin/console", "bin/setup", "lib/sync.rb", "sync.gemspec"]
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "test-unit"
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: sync
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Keiju ISHITSUKA
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-12-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A module that provides a two-phase lock with a counter.
+email:
+- keiju@ruby-lang.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/sync.rb
+- sync.gemspec
+homepage: https://github.com/ruby/sync
+licenses:
+- BSD-2-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: A module that provides a two-phase lock with a counter.
+test_files: []