thread_tools 0.23

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 Daniel Tralamazza <daniel@tralamazza.com>
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,57 @@
+= thread_tools
+
+* http://github.com/differential/thread_tools
+
+== DESCRIPTION:
+
+A collection of utilities that I often use for threaded code.
+
+== FEATURES/PROBLEMS:
+
+* Thread pool
+* Mongrel patch (thread pool)
+* Semaphore
+* Debug mutex
+
+== SYNOPSIS:
+
+* Bounded thread pool
+ require 'thread_tools/threadpool'
+ 
+ tpool = ThreadTools::ThreadPool.new(2)
+ 10.times {|i|
+   tpool.spawn(i) {|ti|
+       puts "#{Thread.current} => #{ti}"
+   }
+ }
+ tpool.shutdown
+
+* Stupid simple semaphore
+ require 'thread_tools/semaphore'
+ 
+ sem = ThreadTools::Semaphore.new(1)
+ sem.acquire
+ sem.release
+
+* Thread pool for Mongrel
+ require 'mongrel'
+ require 'thread_tools/mongrel_pool'
+ 
+ server = Mongrel::HttpServer.new(host, port)
+ server.run(10).join
+
+== REQUIREMENTS:
+
+* Mongrel patch requires mongrel (duh)
+* Rake if you want to run the test cases
+
+== INSTALL:
+
+ gem install thread_tools
+or
+ gem build thread_tools.gemspec
+ gem install thread_tools-<version>.gem
+
+== LICENSE:
+
+see LICENSE

data/lib/thread_tools/debugmutex.rb

@@ -0,0 +1,56 @@
+# Author: Daniel Tralamazza
+# Date: 29 Sep 2009
+#
+# Mutex
+#
+# This class will make things slower, expect more contentions than normal
+# I derived this mutex because I needed to check contention levels and trace
+# owner changes
+
+require 'thread'
+
+
+module ThreadTools
+
+    class DebugMutex < Mutex
+        attr_reader :contentions
+        attr_reader :owner
+
+        def initialize
+            @contentions = 0
+        end
+
+        def lock
+            unless try_lock
+                super
+                @owner = Thread.current
+            end
+            self
+        end
+
+        def try_lock
+            ret = super
+            unless (ret)
+                @contentions += 1
+            else
+                @owner = Thread.current
+            end
+            ret
+        end
+
+        def unlock
+            @owner = nil
+            super
+        end
+
+        def synchronize
+            lock
+            begin
+                yield
+            ensure
+                unlock
+            end
+        end
+    end
+
+end

data/lib/thread_tools/mongrel_pool.rb

@@ -0,0 +1,76 @@
+# Author: Daniel Tralamazza
+# Date: 28 Sep 2009
+#
+# This code patches mongrel to use a thread pool instead of creating a new thread
+# for every request. It also traps SIGTERM to close all connections
+# Changed method run to accept an extra parameter to set thread pool size
+#
+
+
+require File.expand_path(File.dirname(__FILE__)+'/threadpool')
+
+
+module Mongrel
+    class HttpServer
+
+        def run(_pool_size = 100)
+            trap("TERM") { stop } # trap "kill"
+
+            @thread_pool = ThreadTools::ThreadPool.new(_pool_size, @workers)
+
+            BasicSocket.do_not_reverse_lookup = true
+
+            configure_socket_options
+
+            if defined?($tcp_defer_accept_opts) and $tcp_defer_accept_opts
+                @socket.setsockopt(*$tcp_defer_accept_opts) rescue nil
+            end
+
+            @acceptor = Thread.new do
+                begin
+                    while true
+                        begin
+                            client = @socket.accept
+
+                            if defined?($tcp_cork_opts) and $tcp_cork_opts
+                                client.setsockopt(*$tcp_cork_opts) rescue nil
+                            end
+
+                            worker_list = @workers.list
+
+                            if worker_list.length >= @num_processors
+                                STDERR.puts "Server overloaded with #{worker_list.length} processors (#@num_processors max). Dropping connection."
+                                client.close rescue nil
+                                reap_dead_workers("max processors")
+                            else
+                                @thread_pool.spawn(client) do |c|
+                                    Thread.current[:started_on] = Time.now
+                                    process_client(c)
+                                end
+                                sleep @throttle if @throttle > 0
+                            end
+                        rescue StopServer
+                            break
+                        rescue Errno::EMFILE
+                            reap_dead_workers("too many open files")
+                            sleep 0.5
+                        rescue Errno::ECONNABORTED
+                            # client closed the socket even before accept
+                            client.close rescue nil
+                        rescue Object => e
+                            STDERR.puts "#{Time.now}: Unhandled listen loop exception #{e.inspect}."
+                            STDERR.puts e.backtrace.join("\n")
+                        end
+
+                    end
+                    @thread_pool.shutdown
+                    graceful_shutdown
+                ensure
+                    @socket.close
+                    # STDERR.puts "#{Time.now}: Closed socket."
+                end
+            end
+            @acceptor
+        end
+    end
+end

data/lib/thread_tools/semaphore.rb

@@ -0,0 +1,39 @@
+# Author: Daniel Tralamazza
+# Date: 
+#
+# Semaphore
+#
+
+
+require 'thread'
+
+
+module ThreadTools
+
+    # Poor man's semaphore
+    class Semaphore
+        attr_reader :count
+        def initialize(_count)
+            @count = _count
+            @mtx = Mutex.new
+            @cv = ConditionVariable.new
+        end
+
+        def acquire
+            @mtx.synchronize do
+                @cv.wait(@mtx) until @count > 0
+                @count -= 1
+            end
+            @count
+        end
+
+        def release
+            @mtx.synchronize do
+                @count += 1
+                @cv.signal
+            end
+            @count
+        end
+    end
+
+end

data/lib/thread_tools/threadpool.rb

@@ -0,0 +1,101 @@
+# Author: Daniel Tralamazza
+# Date: 25 Sep 2009
+#
+# ThreadPool
+#
+# Usage:
+#
+# tpool = ThreadTools::ThreadPool.new(3)
+# 12.times do |i|
+#   tpool.spawn(i, "hi") {|ti, ts|
+#     puts "#{Thread.current} (#{ti}) says #{ts}\n"
+#   }
+# end
+# tpool.shutdown
+
+
+require 'thread'
+require File.expand_path(File.dirname(__FILE__)+'/semaphore')
+
+
+module ThreadTools
+
+    class ThreadPool
+        # kill the worker thread if an excpetion is raised (default false)
+        attr_accessor :kill_worker_on_exception
+        # number of worker threads
+        attr_reader :size
+
+        # _size should be at least 1
+        def initialize(_size, _thr_group = nil)
+            @kill_worker_on_exception = false
+            @size = 0
+            @pool_mtx = Mutex.new
+            @pool_cv = ConditionVariable.new
+            @pool = []
+            @thr_grp = _thr_group
+            _size = 1 if _size < 1
+            _size.times { create_worker }
+        end
+
+        def create_worker
+            Thread.new do
+                thr = Thread.current
+                @pool_mtx.synchronize do
+                    @size += 1
+                    if (!@thr_grp.nil?)
+                        @thr_grp.add(thr)
+                    end
+                end
+                thr[:jobs] = []         # XXX array not really necessary
+                thr[:sem] = Semaphore.new(0)
+                loop do
+                    @pool_mtx.synchronize do
+                        @pool << thr    # puts this thread in the pool
+                        @pool_cv.signal
+                    end
+                    thr[:sem].acquire   # wait here for jobs to become available
+                    job = thr[:jobs].shift  # pop out a job
+                    if (job.nil? || job[:block].nil?)
+                        break           # exit thread if job or block is nil
+                    end
+                    begin
+                        job[:block].call(*job[:args])       # call block
+                    rescue
+                        if (@kill_worker_on_exception)
+                            break       # exit thread on exception
+                        end
+                    end
+                end
+                @pool_mtx.synchronize do
+                    @size -= 1
+                end
+            end
+        end
+
+        def spawn(*args, &block)
+            thr = nil
+            @pool_mtx.synchronize do
+                # wait here until a worker is available
+                @pool_cv.wait(@pool_mtx) until !(thr = @pool.shift).nil?
+                thr[:jobs] << { :args => args, :block => block }
+                thr[:sem].release
+            end
+            thr
+        end
+
+        def shutdown
+            thr = nil
+            while !@pool.empty? do
+                @pool_mtx.synchronize do
+                    @pool_cv.wait(@pool_mtx) until !(thr = @pool.shift).nil?
+                end
+                thr[:jobs].clear    # clear any pending job
+                thr[:jobs] << nil   # queue a nil job
+                thr[:sem].release
+                thr.join            # wait here for the thread to die
+            end
+        end
+    end
+
+end

data/test/test_mongrel.rb

@@ -0,0 +1,45 @@
+require 'test/unit'
+require 'mongrel'
+require File.expand_path(File.dirname(__FILE__)+'/../lib/thread_tools/mongrel_pool')
+require 'net/http'
+
+
+class MongrelPoolTest < Test::Unit::TestCase
+    class MyHandler < Mongrel::HttpHandler
+        attr_reader :uniq_threads
+        def initialize()
+            super
+            @uniq_threads = {}
+        end
+        def process(req, res)
+            @uniq_threads[Thread.current] = true
+            res.start do |head,out|
+                head["Content-Type"] = "text/html; charset=\"utf-8\""
+                out << "test"
+            end
+        end
+    end
+
+    def setup
+        super
+        @server = Mongrel::HttpServer.new("127.0.0.1", 18881)
+        @handler = MyHandler.new
+        @server.register("/", @handler)
+        @acceptor = @server.run(2)
+    end
+
+    def test_send_recv_shutdown
+        http = Net::HTTP.new("localhost", 18881)
+        4.times {
+            headers, body = http.get("/")
+            # received correct response
+            assert_equal(headers.code, "200")
+            assert_equal(body, "test")
+        }
+        # number of unique threads
+        assert_equal(@handler.uniq_threads.size, 2)
+        @server.stop(true)
+        # all workers are dead
+        assert_equal(@server.workers.list.size, 0)
+    end
+end

data/test/test_semaphore.rb

@@ -0,0 +1,25 @@
+require 'test/unit'
+require File.expand_path(File.dirname(__FILE__)+'/../lib/thread_tools/semaphore')
+
+
+class SemaphoreTest < Test::Unit::TestCase
+    def test_acquire_release
+        sem = ThreadTools::Semaphore.new(1)
+        # should be able to acquire
+        assert_equal(sem.acquire, 0)
+        ok = false
+        Thread.new do
+            # should block here
+            sem.acquire
+            # and unblock
+            ok = true
+        end
+        Thread.pass
+        sem.release
+        sleep 0.1
+        # release should unblock acquire
+        assert_equal(ok, true)
+        # semaphore count has to be 0
+        assert_equal(sem.count, 0)
+    end
+end

data/test/test_threadpool.rb

@@ -0,0 +1,41 @@
+require 'test/unit'
+require File.expand_path(File.dirname(__FILE__)+'/../lib/thread_tools/threadpool')
+
+
+class ThreadPoolTest < Test::Unit::TestCase
+    def setup
+        super
+        @tpool = ThreadTools::ThreadPool.new(2)
+        @tpool.kill_worker_on_exception = true
+    end
+
+    def test_thread_spawn
+        uniq_threads = {}
+        sum_orig = 0
+        sum_lock = Mutex.new
+        sum_thr = 0
+        4.times {|i|
+            sum_orig += i
+            @tpool.spawn(i) {|ti|
+                sum_lock.synchronize do
+                    sum_thr += ti
+                end
+                uniq_threads[Thread.current] = true
+                if (ti == 3)
+                  # this exception should kill this worker
+                  raise "oups"
+                end
+            }
+        }
+        sleep 0.1
+        # 2 workers - 1 from raised exceptions = 1
+        assert_equal(@tpool.size, 1)
+        @tpool.shutdown
+        # same sum
+        assert_equal(sum_orig, sum_thr)
+        # number of different threads
+        assert_equal(uniq_threads.size, 2)
+        # after shutdown all threads are dead
+        assert_equal(@tpool.size, 0)
+    end
+end

data/thread_tools.gemspec

@@ -0,0 +1,32 @@
+Gem::Specification.new do |s|
+    s.name = %q{thread_tools}
+    s.version = '0.23'
+    s.summary = %q{Utilities for threaded apps}
+    s.platform = Gem::Platform::RUBY
+    s.email = %q{daniel@tralamazza.com}
+    s.homepage = %q{http://github.com/differential/thread_tools}
+    s.description = %q{Thread tools is a collection of classes and utilities to help you write threaded code.}
+    s.has_rdoc = true
+    s.authors = ['Daniel Tralamazza']
+    s.files = [
+        'thread_tools.gemspec',
+        'README.rdoc',
+        'LICENSE',
+        'lib/thread_tools/threadpool.rb',
+        'lib/thread_tools/mongrel_pool.rb',
+        'lib/thread_tools/semaphore.rb',
+        'lib/thread_tools/debugmutex.rb',
+        'test/test_mongrel.rb',
+        'test/test_semaphore.rb',
+        'test/test_threadpool.rb', 
+    ]
+    s.test_files = [
+        'test/test_mongrel.rb',
+        'test/test_semaphore.rb',
+        'test/test_threadpool.rb', 
+    ]
+    s.rdoc_options = ['--main', 'README.rdoc']
+    s.extra_rdoc_files = ['README.rdoc']
+    s.require_paths = ['lib']
+    s.rubyforge_project = 'threadtools'
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: thread_tools
+version: !ruby/object:Gem::Version 
+  version: "0.23"
+platform: ruby
+authors: 
+- Daniel Tralamazza
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-05 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Thread tools is a collection of classes and utilities to help you write threaded code.
+email: daniel@tralamazza.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- thread_tools.gemspec
+- README.rdoc
+- LICENSE
+- lib/thread_tools/threadpool.rb
+- lib/thread_tools/mongrel_pool.rb
+- lib/thread_tools/semaphore.rb
+- lib/thread_tools/debugmutex.rb
+- test/test_mongrel.rb
+- test/test_semaphore.rb
+- test/test_threadpool.rb
+has_rdoc: true
+homepage: http://github.com/differential/thread_tools
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: threadtools
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Utilities for threaded apps
+test_files: 
+- test/test_mongrel.rb
+- test/test_semaphore.rb
+- test/test_threadpool.rb