tsafe 0.0.1 → 0.0.2

data/Gemfile.lock

@@ -3,12 +3,12 @@ GEM
   specs:
     diff-lcs (1.1.3)
     git (1.2.5)
-    jeweler (1.8.3)
+    jeweler (1.8.4)
       bundler (~> 1.0)
       git (>= 1.2.5)
       rake
       rdoc
-    json (1.7.1)
+    json (1.7.3)
     rake (0.9.2.2)
     rdoc (3.12)
       json (~> 1.4)

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/include/monarray.rb

@@ -0,0 +1,12 @@
+#Predefined synchronized array.
+#
+#===Examples
+# arr = Tsafe::MonArray.new
+# arr << 5
+# ret = arr[0]
+class Tsafe::MonArray < ::Array
+  @@tsafe_rwmutex_w_methods = [:<<, :collect, :collect!, :compact!, :delete, :delete_at, :delete_if, :drop, :drop_while, :fill, :flatten!, :insert, :keep_if, :map, :map!, :replace, :shuffle!, :slice!, :shift, :sort!, :sort_by!, :unshift]
+  @@tsafe_rwmutex_r_methods = [:each, :each_index, :take_while]
+  
+  include Tsafe::SynModule
+end

data/include/monhash.rb

@@ -0,0 +1,12 @@
+#Predefined synchronized hash.
+#
+#===Examples
+# h = Tsafe::MonHash.new
+# h['test'] = 'trala'
+# ret = h['test']
+class Tsafe::MonHash < ::Hash
+  @@tsafe_rwmutex_w_methods = [:[]=, :clear, :delete, :delete_if, :keep_if, :merge!, :rehash, :reject!, :replace, :select!, :shift, :store, :update, :values_at]
+  @@tsafe_rwmutex_r_methods = [:each, :each_key, :each_pair, :each_value]
+  
+  include Tsafe::Mrswlock::SynModule
+end

data/include/monitored.rb

@@ -0,0 +1,29 @@
+#This module can be included on a class to make all method-calls synchronized (by using monitor). Examples with array and hash are below.
+#
+#===Examples
+# class MySyncedClass < SomeOtherClassThatNeedsToBeSynchronized
+#   include Tsafe::Monitored
+# end
+module Tsafe::Monitored
+  def self.included(base)
+    base.to_s.split("::").inject(Object, :const_get).class_eval do
+      self.instance_methods.each do |method_name|
+        #These two methods create warnings under JRuby.
+        if RUBY_ENGINE == "jruby"
+          next if method_name == :instance_exec or method_name == :instance_eval
+        end
+        
+        new_method_name = "_ts_#{method_name}"
+        alias_method(new_method_name, method_name)
+        
+        define_method method_name do |*args, &block|
+          #Need to use monitor, since the internal calls might have to run not-synchronized, and we have just overwritten the internal methods.
+          @_ts_mutex = Monitor.new if !@_ts_mutex
+          @_ts_mutex.synchronize do
+            return self._ts___send__(new_method_name, *args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/include/mrswlock.rb

@@ -0,0 +1,75 @@
+#A class that allows many simultanious read-synchronizations but locks both reading and writing while calling the write-synchronzie-method.
+class Tsafe::Mrswlock
+  @@debug = false
+  
+  #Sets various variables.
+  def initialize
+    @reads = 0
+    @w_mutex = Mutex.new
+  end
+  
+  #Runs the given block through the read-synchronization.
+  def rsync
+    begin
+      while @w_mutex.locked?
+        Thread.pass
+        print "Passed because lock.\n" if @@debug
+      end
+      
+      @reads += 1
+      print "Reading more than one at a time! (#{@reads})\n" if @@debug and @reads >= 2
+      yield
+    ensure
+      @reads -= 1
+    end
+  end
+  
+  #Runs the given block through the write-synchronization (locks both reading and writing).
+  def wsync
+    @w_mutex.synchronize do
+      #Wait for any reads to finish that might have started while we were getting the lock.
+      while @reads > 0
+        Thread.pass
+        print "Passed because reading.\n" if @@debug
+      end
+      
+      yield
+    end
+  end
+  
+  module SynModule
+    def self.included(base)
+      base.to_s.split("::").inject(Object, :const_get).class_eval do
+        #Rename initialize.
+        alias_method(:initialize_rwmutex, :initialize)
+        
+        define_method(:initialize) do |*args, &block|
+          @tsafe_rwmutex = Tsafe::Mrswlock.new
+          return initialize_rwmutex(*args, &block)
+        end
+        
+        base.class_variable_get(:@@tsafe_rwmutex_r_methods).each do |mname|
+          newmname = "tsafe_rwmutex_#{mname}".to_sym
+          alias_method(newmname, mname)
+          
+          define_method(mname) do |*args, &block|
+            @tsafe_rwmutex.rsync do
+              return self.__send__(newmname, *args, &block)
+            end
+          end
+        end
+        
+        base.class_variable_get(:@@tsafe_rwmutex_w_methods).each do |mname|
+          newmname = "tsafe_rwmutex_#{mname}".to_sym
+          alias_method(newmname, mname)
+          
+          define_method(mname) do |*args, &block|
+            @tsafe_rwmutex.wsync do
+              return self.__send__(newmname, *args, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/include/mutexed.rb

@@ -0,0 +1,29 @@
+#This module can be included on a class to make all method-calls synchronized (by using mutex). Examples with array and hash are below.
+#
+#===Examples
+# class MySyncedClass < SomeOtherClassThatNeedsToBeSynchronized
+#   include Tsafe::Mutexed
+# end
+module Tsafe::Mutexed
+  def self.included(base)
+    base.to_s.split("::").inject(Object, :const_get).class_eval do
+      self.instance_methods.each do |method_name|
+        #These two methods create warnings under JRuby.
+        if RUBY_ENGINE == "jruby"
+          next if method_name == :instance_exec or method_name == :instance_eval
+        end
+        
+        new_method_name = "_ts_#{method_name}"
+        alias_method(new_method_name, method_name)
+        
+        define_method method_name do |*args, &block|
+          #Need to use monitor, since the internal calls might have to run not-synchronized, and we have just overwritten the internal methods.
+          @_ts_mutex = Mutex.new if !@_ts_mutex
+          @_ts_mutex.synchronize do
+            return self._ts___send__(new_method_name, *args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/include/proxy.rb

@@ -0,0 +1,29 @@
+#Instances of this class proxies calls to a given-object by using a mutex or monitor.
+#
+#==== Examples
+# threadsafe_array = Tsafe::Proxy.new(:obj => [])
+# threadsafe_array << 5
+# ret = threadsafe_array[0]
+#
+# threadsafe_array = Tsafe::Proxy.new(:obj => [], :monitor => true)
+class Tsafe::Proxy
+  #Spawn needed vars.
+  def initialize(args)
+    if args[:monitor]
+      @mutex = Monitor.new
+    elsif args[:mutex]
+      @mutex = args[:mutex]
+    else
+      @mutex = Mutex.new
+    end
+    
+    @obj = args[:obj]
+  end
+  
+  #Proxies all calls to this object through the mutex.
+  def method_missing(method_name, *args, &block)
+    @mutex.synchronize do
+      @obj.__send__(method_name, *args, &block)
+    end
+  end
+end

data/lib/tsafe.rb

@@ -2,119 +2,16 @@ require "monitor"
 
 #This module contains various tools to handle thread-safety easily and pretty.
 module Tsafe
+  #Autoloader for subclasses.
+  def self.const_missing(name)
+    require "#{File.dirname(__FILE__)}/../include/#{name.to_s.downcase}.rb"
+    raise "Still not loaded: '#{name}'." if !Tsafe.const_defined?(name)
+    return Tsafe.const_get(name)
+  end
+  
   #JRuby can corrupt an array in a threadded env. Use this method to only get a synchronized array when running JRuby and not having to write "if RUBY_ENGINE"-stuff.
   def self.std_array
     return MonArray.new if RUBY_ENGINE == "jruby"
     return []
   end
-  
-  #Instances of this class proxies calls to a given-object by using a mutex or monitor.
-  #
-  #==== Examples
-  # threadsafe_array = Tsafe::Proxy.new(:obj => [])
-  # threadsafe_array << 5
-  # ret = threadsafe_array[0]
-  #
-  # threadsafe_array = Tsafe::Proxy.new(:obj => [], :monitor => true)
-  class Proxy
-    #Spawn needed vars.
-    def initialize(args)
-      if args[:monitor]
-        @mutex = Monitor.new
-      elsif args[:mutex]
-        @mutex = args[:mutex]
-      else
-        @mutex = Mutex.new
-      end
-      
-      @obj = args[:obj]
-    end
-    
-    #Proxies all calls to this object through the mutex.
-    def method_missing(method_name, *args, &block)
-      @mutex.synchronize do
-        @obj.__send__(method_name, *args, &block)
-      end
-    end
-  end
-  
-  #This module can be included on a class to make all method-calls synchronized (by using monitor). Examples with array and hash are below.
-  #
-  #===Examples
-  # class MySyncedClass < SomeOtherClassThatNeedsToBeSynchronized
-  #   include Tsafe::Monitored
-  # end
-  module Monitored
-    def self.included(base)
-      base.to_s.split("::").inject(Object, :const_get).class_eval do
-        self.instance_methods.each do |method_name|
-          #These two methods create warnings under JRuby.
-          if RUBY_ENGINE == "jruby"
-            next if method_name == :instance_exec or method_name == :instance_eval
-          end
-          
-          new_method_name = "_ts_#{method_name}"
-          alias_method(new_method_name, method_name)
-          
-          define_method method_name do |*args, &block|
-            #Need to use monitor, since the internal calls might have to run not-synchronized, and we have just overwritten the internal methods.
-            @_ts_mutex = Monitor.new if !@_ts_mutex
-            @_ts_mutex.synchronize do
-              return self._ts___send__(new_method_name, *args, &block)
-            end
-          end
-        end
-      end
-    end
-  end
-  
-  #This module can be included on a class to make all method-calls synchronized (by using mutex). Examples with array and hash are below.
-  #
-  #===Examples
-  # class MySyncedClass < SomeOtherClassThatNeedsToBeSynchronized
-  #   include Tsafe::Mutexed
-  # end
-  module Mutexed
-    def self.included(base)
-      base.to_s.split("::").inject(Object, :const_get).class_eval do
-        self.instance_methods.each do |method_name|
-          #These two methods create warnings under JRuby.
-          if RUBY_ENGINE == "jruby"
-            next if method_name == :instance_exec or method_name == :instance_eval
-          end
-          
-          new_method_name = "_ts_#{method_name}"
-          alias_method(new_method_name, method_name)
-          
-          define_method method_name do |*args, &block|
-            #Need to use monitor, since the internal calls might have to run not-synchronized, and we have just overwritten the internal methods.
-            @_ts_mutex = Mutex.new if !@_ts_mutex
-            @_ts_mutex.synchronize do
-              return self._ts___send__(new_method_name, *args, &block)
-            end
-          end
-        end
-      end
-    end
-  end
-  
-  #Predefined synchronized array.
-  #
-  #===Examples
-  # arr = Tsafe::MonArray.new
-  # arr << 5
-  # ret = arr[0]
-  class MonArray < ::Array
-    include Monitored
-  end
-  
-  #Predefined synchronized hash.
-  #
-  #===Examples
-  # h = Tsafe::MonHash.new
-  # h['test'] = 'trala'
-  # ret = h['test']
-  class MonHash < ::Hash
-    include Monitored
-  end
 end

data/spec/mrswlock_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Tsafe::Rwmutex" do
+  it "should work!" do
+    Thread.abort_on_exception = true
+    debug = false
+    
+    print "Setting initial values.\n" if debug
+    hash = Tsafe::MonHash.new
+    0.upto(15) do |count|
+      realcount = 100000000 - count
+      hash[realcount] = realcount
+    end
+    
+    ts = []
+    
+    1.upto(20) do |tcount|
+      print "Starting thread #{tcount}\n" if debug
+      ts << Thread.new do
+        1.upto(10000) do |count|
+          hash[count] = count
+          
+          hash[count]
+          hash.key?(count)
+          
+          hash.delete(count)
+          
+          hash.each do |key, val|
+            #nothing...
+          end
+        end
+      end
+    end
+    
+    ts.each do |t|
+      print "Joining #{t.__id__}\n" if debug
+      t.join
+    end
+  end
+  
+  it "should work!" do
+    debug = false
+    
+    hash = {}
+    0.upto(15) do |count|
+      realcount = 100000000 - count
+      hash[realcount] = realcount
+    end
+    
+    rwm = Tsafe::Mrswlock.new
+    ts = []
+    
+    1.upto(20) do
+      ts << Thread.new do
+        1.upto(10000) do |count|
+          rwm.wsync do
+            hash[count] = count
+          end
+          
+          rwm.rsync do
+            hash[count]
+            hash.key?(count)
+          end
+          
+          rwm.wsync do
+            hash.delete(count)
+          end
+          
+          rwm.rsync do
+            hash.each do |key, val|
+              #nothing...
+            end
+          end
+        end
+      end
+    end
+    
+    ts.each do |t|
+      print "Joining #{t.__id__}\n" if debug
+      t.join
+    end
+  end
+end

data/tsafe.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{tsafe}
-  s.version = "0.0.1"
+  s.version = "0.0.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Kasper Johansen"]
-  s.date = %q{2012-05-12}
+  s.date = %q{2012-07-25}
   s.description = %q{Proxy-objects for making another object threadsafe by proxying calls through mutex and method_missing. Monitored array and hash where all methods are going through monitor. Threadsafe class for including into a class that extends another class in order to make it threadsafe.}
   s.email = %q{k@spernj.org}
   s.extra_rdoc_files = [
@@ -25,7 +25,14 @@ Gem::Specification.new do |s|
     "README.rdoc",
     "Rakefile",
     "VERSION",
+    "include/monarray.rb",
+    "include/monhash.rb",
+    "include/monitored.rb",
+    "include/mrswlock.rb",
+    "include/mutexed.rb",
+    "include/proxy.rb",
     "lib/tsafe.rb",
+    "spec/mrswlock_spec.rb",
     "spec/spec_helper.rb",
     "spec/tsafe_spec.rb",
     "tsafe.gemspec"

metadata

@@ -2,7 +2,7 @@
 name: tsafe
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Kasper Johansen
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-05-12 00:00:00 +02:00
+date: 2012-07-25 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -75,7 +75,14 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
+- include/monarray.rb
+- include/monhash.rb
+- include/monitored.rb
+- include/mrswlock.rb
+- include/mutexed.rb
+- include/proxy.rb
 - lib/tsafe.rb
+- spec/mrswlock_spec.rb
 - spec/spec_helper.rb
 - spec/tsafe_spec.rb
 - tsafe.gemspec
@@ -93,7 +100,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 1960429092658754527
+      hash: -2173245037077318773
       segments: 
       - 0
       version: "0"