vinted-thread 0.1.1

data/lib/thread/future.rb

@@ -0,0 +1,158 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'thread'
+
+# A future is an object that incapsulates a block which is called in a
+# different thread, upon retrieval the caller gets blocked until the block has
+# finished running, and its result is returned and cached.
+class Thread::Future
+	Cancel = Class.new(Exception)
+
+	# Create a future with the passed block and optionally using the passed pool.
+	def initialize (pool = nil, &block)
+		raise ArgumentError, 'no block given' unless block
+
+		@mutex = Mutex.new
+
+		task = proc {
+			begin
+				deliver block.call
+			rescue Exception => e
+				@exception = e
+
+				deliver nil
+			end
+		}
+
+		@thread = pool ? pool.process(&task) : Thread.new(&task)
+
+		ObjectSpace.define_finalizer self, self.class.finalizer(@thread)
+	end
+
+	# @private
+	def self.finalizer (thread)
+		proc {
+			thread.raise Cancel.new
+		}
+	end
+
+	# Check if an exception has been raised.
+	def exception?
+		@mutex.synchronize {
+			instance_variable_defined? :@exception
+		}
+	end
+
+	# Return the raised exception.
+	def exception
+		@mutex.synchronize {
+			@exception
+		}
+	end
+
+	# Check if the future has been called.
+	def delivered?
+		@mutex.synchronize {
+			instance_variable_defined? :@value
+		}
+	end
+
+	alias realized? delivered?
+
+	# Cancel the future, {#value} will yield a Cancel exception
+	def cancel
+		return self if delivered?
+
+		@mutex.synchronize {
+			@thread.raise Cancel.new('future cancelled')
+		}
+
+		self
+	end
+
+	# Check if the future has been cancelled
+	def cancelled?
+		@mutex.synchronize {
+			@exception.is_a? Cancel
+		}
+	end
+
+	# Get the value of the future, if it's not finished running this call will block.
+	#
+	# In case the block raises an exception, it will be raised, the exception is cached
+	# and will be raised every time you access the value.
+	#
+	# An optional timeout can be passed which will return nil if nothing has been
+	# delivered.
+	def value (timeout = nil)
+		raise @exception if exception?
+
+		return @value if delivered?
+
+		@mutex.synchronize {
+			cond.wait(@mutex, *timeout)
+		}
+
+		if exception?
+			raise @exception
+		elsif delivered?
+			return @value
+		end
+	end
+
+	alias ~ value
+
+	# Do the same as {#value}, but return nil in case of exception.
+	def value! (timeout = nil)
+		begin
+			value(timeout)
+		rescue Exception
+			nil
+		end
+	end
+
+	alias ! value!
+
+private
+	def cond?
+		instance_variable_defined? :@cond
+	end
+
+	def cond
+		@cond ||= ConditionVariable.new
+	end
+
+	def deliver (value)
+		return if delivered?
+
+		@mutex.synchronize {
+			@value = value
+
+			cond.broadcast if cond?
+		}
+
+		self
+	end
+end
+
+class Thread
+	# Helper to create a future
+	def self.future (pool = nil, &block)
+		Thread::Future.new(pool, &block)
+	end
+end
+
+module Kernel
+	# Helper to create a future.
+	def future (pool = nil, &block)
+		Thread::Future.new(pool, &block)
+	end
+end

data/lib/thread/pipe.rb

@@ -0,0 +1,119 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'thread'
+
+# A pipe lets you execute various tasks on a set of data in parallel,
+# each datum inserted in the pipe is passed along through queues to the various
+# functions composing the pipe, the final result is inserted in the final queue.
+class Thread::Pipe
+	# A task incapsulates a part of the pipe.
+	class Task
+		attr_accessor :input, :output
+
+		# Create a Task which will call the passed function and get input
+		# from the optional parameter and put output in the optional parameter.
+		def initialize (func, input = Queue.new, output = Queue.new)
+			@input    = input
+			@output   = output
+			@handling = false
+
+			@thread = Thread.new {
+				while true
+					value = @input.deq
+
+					@handling = true
+					begin
+						value = func.call(value)
+						@output.enq value
+					rescue Exception; end
+					@handling = false
+				end
+			}
+		end
+
+		# Check if the task has nothing to do.
+		def empty?
+			!@handling && @input.empty? && @output.empty?
+		end
+
+		# Stop the task.
+		def kill
+			@thread.raise
+		end
+	end
+
+	# Create a pipe using the optionally passed objects as input and
+	# output queue.
+	#
+	# The objects must respond to #enq and #deq, and block on #deq.
+	def initialize (input = Queue.new, output = Queue.new)
+		@tasks = []
+
+		@input  = input
+		@output = output
+
+		ObjectSpace.define_finalizer self, self.class.finalizer(@tasks)
+	end
+
+	# @private
+	def self.finalizer (tasks)
+		proc {
+			tasks.each(&:kill)
+		}
+	end
+
+	# Add a task to the pipe, it must respond to #call and #arity,
+	# and #arity must return 1.
+	def | (func)
+		if func.arity != 1
+			raise ArgumentError, 'wrong arity'
+		end
+
+		Task.new(func, (@tasks.empty? ? @input : Queue.new), @output).tap {|t|
+			@tasks.last.output = t.input unless @tasks.empty?
+			@tasks << t
+		}
+
+		self
+	end
+
+	# Check if the pipe is empty.
+	def empty?
+		@input.empty? && @output.empty? && @tasks.all?(&:empty?)
+	end
+
+	# Insert data in the pipe.
+	def enq (data)
+		return if @tasks.empty?
+
+		@input.enq data
+
+		self
+	end
+
+	alias push enq
+	alias <<   enq
+
+	# Get an element from the output queue.
+	def deq (non_block = false)
+		@output.deq(non_block)
+	end
+	
+	alias pop deq
+	alias ~   deq
+end
+
+class Thread
+	# Helper to create a pipe.
+	def self.| (func)
+		Pipe.new | func
+	end
+end

data/lib/thread/pool.rb

@@ -0,0 +1,428 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'thread'
+
+# A pool is a container of a limited amount of threads to which you can add
+# tasks to run.
+#
+# This is usually more performant and less memory intensive than creating a
+# new thread for every task.
+class Thread::Pool
+	# A task incapsulates a block being ran by the pool and the arguments to pass
+	# to it.
+	class Task
+		Timeout = Class.new(Exception)
+		Asked   = Class.new(Exception)
+
+		attr_reader :pool, :timeout, :exception, :thread, :started_at
+
+		# Create a task in the given pool which will pass the arguments to the
+		# block.
+		def initialize (pool, *args, &block)
+			@pool      = pool
+			@arguments = args
+			@block     = block
+
+			@running    = false
+			@finished   = false
+			@timedout   = false
+			@terminated = false
+		end
+
+		def running?;    @running;   end
+		def finished?;   @finished;   end
+		def timeout?;    @timedout;   end
+		def terminated?; @terminated; end
+
+		# Execute the task in the given thread.
+		def execute (thread)
+			return if terminated? || running? || finished?
+
+			@thread     = thread
+			@running    = true
+			@started_at = Time.now
+
+			pool.__send__ :wake_up_timeout
+
+			begin
+				@block.call(*@arguments)
+			rescue Exception => reason
+				if reason.is_a? Timeout
+					@timedout = true
+				elsif reason.is_a? Asked
+					return
+				else
+					@exception = reason
+				end
+			end
+
+			@running  = false
+			@finished = true
+			@thread   = nil
+		end
+
+		# Raise an exception in the thread used by the task.
+		def raise (exception)
+			@thread.raise(exception)
+		end
+
+		# Terminate the exception with an optionally given exception.
+		def terminate! (exception = Asked)
+			return if terminated? || finished? || timeout?
+
+			@terminated = true
+
+			return unless running?
+
+			self.raise exception
+		end
+
+		# Force the task to timeout.
+		def timeout!
+			terminate! Timeout
+		end
+
+		# Timeout the task after the given time.
+		def timeout_after (time)
+			@timeout = time
+
+			pool.timeout_for self, time
+
+			self
+		end
+	end
+
+	attr_reader :min, :max, :spawned
+
+	# Create the pool with minimum and maximum threads.
+	#
+	# The pool will start with the minimum amount of threads created and will
+	# spawn new threads until the max is reached in case of need.
+	#
+	# A default block can be passed, which will be used to {#process} the passed
+	# data.
+	def initialize (min, max = nil, &block)
+		@min   = min
+		@max   = max || min
+		@block = block
+
+		@cond  = ConditionVariable.new
+		@mutex = Mutex.new
+
+		@done       = ConditionVariable.new
+		@done_mutex = Mutex.new
+
+		@todo     = []
+		@workers  = []
+		@timeouts = {}
+
+		@spawned       = 0
+		@waiting       = 0
+		@shutdown      = false
+		@trim_requests = 0
+		@auto_trim     = false
+		@idle_trim     = nil
+
+		@mutex.synchronize {
+			min.times {
+				spawn_thread
+			}
+		}
+	end
+
+	# Check if the pool has been shut down.
+	def shutdown?; !!@shutdown; end
+
+	# Check if auto trimming is enabled.
+	def auto_trim?
+		@auto_trim
+	end
+
+	# Enable auto trimming, unneeded threads will be deleted until the minimum
+	# is reached.
+	def auto_trim!
+		@auto_trim = true
+	end
+
+	# Disable auto trimming.
+	def no_auto_trim!
+		@auto_trim = false
+	end
+
+	# Check if idle trimming is enabled.
+	def idle_trim?
+		!@idle_trim.nil?
+	end
+
+	# Enable idle trimming. Unneeded threads will be deleted after the given number of seconds of inactivity.
+	# The minimum number of threads is respeced.
+	def idle_trim!(timeout)
+		@idle_trim = timeout
+	end
+
+	# Turn of idle trimming.
+	def no_idle_trim!
+		@idle_trim = nil
+	end
+
+	# Resize the pool with the passed arguments.
+	def resize (min, max = nil)
+		@min = min
+		@max = max || min
+
+		trim!
+	end
+
+	# Get the amount of tasks that still have to be run.
+	def backlog
+		@mutex.synchronize {
+			@todo.length
+		}
+	end
+
+	# Are all tasks consumed ?
+	def done?
+		@todo.empty? and @waiting == @spawned
+	end
+
+	# Wait until all tasks are consumed. The caller will be blocked until then.
+	def wait_done
+		@done_mutex.synchronize {
+			return if done?
+			@done.wait @done_mutex
+		}
+	end
+
+	# Add a task to the pool which will execute the block with the given
+	# argument.
+	#
+	# If no block is passed the default block will be used if present, an
+	# ArgumentError will be raised otherwise.
+	def process (*args, &block)
+		unless block || @block
+			raise ArgumentError, 'you must pass a block'
+		end
+
+		task = Task.new(self, *args, &(block || @block))
+
+		@mutex.synchronize {
+			raise 'unable to add work while shutting down' if shutdown?
+
+			@todo << task
+
+			if @waiting == 0 && @spawned < @max
+				spawn_thread
+			end
+
+			@cond.signal
+		}
+
+		task
+	end
+
+	alias << process
+
+	# Trim the unused threads, if forced threads will be trimmed even if there
+	# are tasks waiting.
+	def trim (force = false)
+		@mutex.synchronize {
+			if (force || @waiting > 0) && @spawned - @trim_requests > @min
+				@trim_requests += 1
+				@cond.signal
+			end
+		}
+
+		self
+	end
+
+	# Force #{trim}.
+	def trim!
+		trim true
+	end
+
+	# Shut down the pool instantly without finishing to execute tasks.
+	def shutdown!
+		@mutex.synchronize {
+			@shutdown = :now
+			@cond.broadcast
+		}
+
+		wake_up_timeout
+
+		self
+	end
+
+	# Shut down the pool, it will block until all tasks have finished running.
+	def shutdown
+		@mutex.synchronize {
+			@shutdown = :nicely
+			@cond.broadcast
+		}
+
+		join
+
+		if @timeout
+			@shutdown = :now
+
+			wake_up_timeout
+
+			@timeout.join
+		end
+
+		self
+	end
+
+	# Join on all threads in the pool.
+	def join
+		until @workers.empty?
+			if worker = @workers.first
+				worker.join
+			end
+		end
+
+		self
+	end
+
+	# Define a timeout for a task.
+	def timeout_for (task, timeout)
+		unless @timeout
+			spawn_timeout_thread
+		end
+
+		@mutex.synchronize {
+			@timeouts[task] = timeout
+
+			wake_up_timeout
+		}
+	end
+
+	# Shutdown the pool after a given amount of time.
+	def shutdown_after (timeout)
+		Thread.new {
+			sleep timeout
+
+			shutdown
+		}
+
+		self
+	end
+
+private
+	def wake_up_timeout
+		if defined? @pipes
+			@pipes.last.write_nonblock 'x' rescue nil
+		end
+	end
+
+	def spawn_thread
+		@spawned += 1
+
+		thread = Thread.new {
+			loop do
+				task = @mutex.synchronize {
+					if @todo.empty?
+						while @todo.empty?
+							if @trim_requests > 0
+								@trim_requests -= 1
+
+								break
+							end
+
+							break if shutdown?
+
+							@waiting += 1
+
+							report_done
+
+							if @idle_trim and @spawned > @min
+								check_time = Time.now + @idle_trim
+								@cond.wait @mutex, @idle_trim
+								@trim_requests += 1 if Time.now >= check_time && @spawned - @trim_requests > @min
+							else
+								@cond.wait @mutex
+							end
+
+							@waiting -= 1
+						end
+
+						break if @todo.empty? && shutdown?
+					end
+
+					@todo.shift
+				} or break
+
+				task.execute(thread)
+
+				break if @shutdown == :now
+
+				trim if auto_trim? && @spawned > @min
+			end
+
+			@mutex.synchronize {
+				@spawned -= 1
+				@workers.delete thread
+			}
+		}
+
+		@workers << thread
+
+		thread
+	end
+	
+	def spawn_timeout_thread
+		@pipes   = IO.pipe
+		@timeout = Thread.new {
+			loop do
+				now     = Time.now
+				timeout = @timeouts.map {|task, time|
+					next unless task.started_at
+
+					now - task.started_at + task.timeout
+				}.compact.min unless @timeouts.empty?
+
+				readable, = IO.select([@pipes.first], nil, nil, timeout)
+
+				break if @shutdown == :now
+
+				if readable && !readable.empty?
+					readable.first.read_nonblock 1024
+				end
+
+				now = Time.now
+				@timeouts.each {|task, time|
+					next if !task.started_at || task.terminated? || task.finished?
+
+					if now > task.started_at + task.timeout
+						task.timeout!
+					end
+				}
+
+				@timeouts.reject! { |task, _| task.terminated? || task.finished? }
+				
+				break if @shutdown == :now
+			end
+		}
+	end
+
+	def report_done
+		@done_mutex.synchronize {
+			@done.broadcast if done?
+		}
+	end
+
+end
+
+class Thread
+	# Helper to create a pool.
+	def self.pool (*args, &block)
+		Thread::Pool.new(*args, &block)
+	end
+end