garcun 0.0.2

data/lib/garcon/task/single_thread_executor.rb

@@ -0,0 +1,97 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# Copyright: (C) 2014-2015 Stefano Harding
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative 'executor'
+
+module Garcon
+
+  class RubySingleThreadExecutor
+    include RubyExecutor
+    include SerialExecutor
+
+    # Create a new thread pool.
+    #
+    # @option opts [Symbol] :fallback_policy (:discard)
+    #   The policy for handling new tasks that are received when the queue size
+    #   has reached `max_queue` or after the executor has shut down.
+    #
+    def initialize(opts = {})
+      @queue  = Queue.new
+      @thread = nil
+      @fallback_policy = opts.fetch(:fallback_policy, :discard)
+      if !FALLBACK_POLICY.include?(fallback)
+        raise ArgumentError, "#{fallback} is not a valid fallback policy"
+      end
+      init_executor
+      enable_at_exit_handler!(opts)
+    end
+
+    protected #      A T T E N Z I O N E   A R E A   P R O T E T T A
+
+    # @!visibility private
+    def execute(*args, &task)
+      supervise
+      @queue << [args, task]
+    end
+
+    # @!visibility private
+    def shutdown_execution
+      @queue << :stop
+      stopped_event.set unless alive?
+    end
+
+    # @!visibility private
+    def kill_execution
+      @queue.clear
+      @thread.kill if alive?
+    end
+
+    # @!visibility private
+    def alive?
+      @thread && @thread.alive?
+    end
+
+    # @!visibility private
+    def supervise
+      @thread = new_worker_thread unless alive?
+    end
+
+    # @!visibility private
+    def new_worker_thread
+      Thread.new do
+        Thread.current.abort_on_exception = false
+        work
+      end
+    end
+
+    # @!visibility private
+    def work
+      loop do
+        task = @queue.pop
+        break if task == :stop
+        begin
+          task.last.call(*task.first)
+        rescue => e
+          Chef::Log.debug "Caught exception => #{e}"
+        end
+      end
+      stopped_event.set
+    end
+  end
+end

data/lib/garcon/task/thread_pool/cached.rb

@@ -0,0 +1,71 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# Copyright: (C) 2014-2015 Stefano Harding
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative 'executor'
+
+module Garcon
+
+  # A thread pool that dynamically grows and shrinks to fit the current
+  # workload. New threads are created as needed, existing threads are reused,
+  # and threads that remain idle for too long are killed and removed from the
+  # pool. These pools are particularly suited to applications that perform a
+  # high volume of short-lived tasks.
+  #
+  # On creation a `CachedThreadPool` has zero running threads. New threads are
+  # created on the pool as new operations are `#post`. The size of the pool
+  # will grow until `#max_length` threads are in the pool or until the number
+  # of threads exceeds the number of running and pending operations. When a new
+  # operation is post to the pool the first available idle thread will be
+  # tasked with the new operation.
+  #
+  # Should a thread crash for any reason the thread will immediately be removed
+  # from the pool. Similarly, threads which remain idle for an extended period
+  # of time will be killed and reclaimed. Thus these thread pools are very
+  # efficient at reclaiming unused resources.
+  #
+  class CachedThreadPool < ThreadPoolExecutor
+    # Create a new thread pool.
+    #
+    # @param [Hash] opts
+    #   The options defining pool behavior.
+    #
+    # @raise [ArgumentError] if `fallback` is not a known policy
+    #
+    # @option opts [Symbol] :fallback (`:abort`)
+    #   The fallback policy
+    #
+    # @api public
+    def initialize(opts = {})
+      fallback = opts.fetch(:fallback, :abort)
+
+      unless FALLBACK_POLICY.include?(fallback)
+        raise ArgumentError, "#{fallback} is not a valid fallback policy"
+      end
+
+      opts = opts.merge(
+        min_threads: 0,
+        max_threads: DEFAULT_MAX_POOL_SIZE,
+        fallback:    fallback,
+        max_queue:   DEFAULT_MAX_QUEUE_SIZE,
+        idletime:    DEFAULT_THREAD_IDLETIMEOUT)
+
+      super(opts)
+    end
+  end
+end

data/lib/garcon/task/thread_pool/executor.rb

@@ -0,0 +1,294 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# Copyright: (C) 2014-2015 Stefano Harding
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'thread'
+require_relative 'worker'
+require_relative '../event'
+require_relative '../executor'
+require_relative '../monotonic_time'
+
+module Garcon
+
+  class ThreadPoolExecutor
+    include RubyExecutor
+
+    # Default maximum number of threads that will be created in the pool.
+    DEFAULT_MAX_POOL_SIZE      = 2**15 # 32768
+
+    # Default minimum number of threads that will be retained in the pool.
+    DEFAULT_MIN_POOL_SIZE      = 0
+
+    # Default maximum number of tasks that may be added to the task queue.
+    DEFAULT_MAX_QUEUE_SIZE     = 0
+
+    # Default maximum number of seconds a thread in the pool may remain idle
+    # before being reclaimed.
+    DEFAULT_THREAD_IDLETIMEOUT = 60
+
+    # The maximum number of threads that may be created in the pool.
+    attr_reader :max_length
+
+    # The minimum number of threads that may be retained in the pool.
+    attr_reader :min_length
+
+    # The largest number of threads that have been created in the pool since
+    # construction.
+    attr_reader :largest_length
+
+    # The number of tasks that have been scheduled for execution on the pool
+    # since construction.
+    attr_reader :scheduled_task_count
+
+    # The number of tasks that have been completed by the pool since
+    # construction.
+    attr_reader :completed_task_count
+
+    # The number of seconds that a thread may be idle before being reclaimed.
+    attr_reader :idletime
+
+    # The maximum number of tasks that may be waiting in the work queue at any
+    # one time. When the queue size reaches `max_queue` subsequent tasks will be
+    # rejected in accordance with the configured `fallback`.
+    attr_reader :max_queue
+
+    # Create a new thread pool.
+    #
+    # @param [Hash] opts
+    #   The options which configure the thread pool.
+    #
+    # @option opts [Integer] :max_threads (DEFAULT_MAX_POOL_SIZE)
+    #   The maximum number of threads to be created.
+    #
+    # @option opts [Integer] :min_threads (DEFAULT_MIN_POOL_SIZE)
+    #   The minimum number of threads to be retained.
+    #
+    # @option opts [Integer] :idletime (DEFAULT_THREAD_IDLETIMEOUT)
+    #   Maximum number of seconds a thread may be idle before being reclaimed.
+    #
+    # @option opts [Integer] :max_queue (DEFAULT_MAX_QUEUE_SIZE)
+    #   The maximum number of tasks allowed in the work queue at any one time;
+    #   a value of zero means the queue may grow without bound.
+    #
+    # @option opts [Symbol] :fallback (:abort)
+    #   The policy for handling new tasks that are received when the queue size
+    #   has reached `max_queue` or the executor has shut down.
+    #
+    # @raise [ArgumentError] if `:max_threads` is less than one
+    #
+    # @raise [ArgumentError] if `:min_threads` is less than zero
+    #
+    # @raise [ArgumentError] if `:fallback` is not one of the values specified
+    #   in `FALLBACK_POLICY`
+    #
+    def initialize(opts = {})
+      @min_length = opts.fetch(:min_threads, DEFAULT_MIN_POOL_SIZE).to_i
+      @max_length = opts.fetch(:max_threads, DEFAULT_MAX_POOL_SIZE).to_i
+      @idletime   = opts.fetch(:idletime,    DEFAULT_THREAD_IDLETIMEOUT).to_i
+      @max_queue  = opts.fetch(:max_queue,   DEFAULT_MAX_QUEUE_SIZE).to_i
+      @fallback   = opts.fetch(:fallback,    :abort)
+
+      if @max_length <= 0
+        raise ArgumentError, 'max_threads must be greater than zero'
+      elsif @min_length < 0
+        raise ArgumentError, 'min_threads cannot be less than zero'
+      elsif min_length > max_length
+        raise ArgumentError, 'min_threads cannot be more than max_threads'
+      elsif !FALLBACK_POLICY.include?(@fallback)
+        raise ArgumentError, "#{fallback} is not a valid fallback policy"
+      end
+
+      init_executor
+      enable_at_exit_handler!(opts)
+
+      @pool                 = []
+      @queue                = Queue.new
+      @scheduled_task_count = 0
+      @completed_task_count = 0
+      @largest_length       = 0
+
+      @gc_interval  = opts.fetch(:gc_interval, 1).to_i
+      @last_gc_time = Garcon.monotonic_time - [1.0, (@gc_interval * 2.0)].max
+    end
+
+    # @!macro executor_module_method_can_overflow_question
+    def can_overflow?
+      @max_queue != 0
+    end
+
+    # The number of threads currently in the pool.
+    #
+    # @return [Integer] the length
+    def length
+      mutex.synchronize { running? ? @pool.length : 0 }
+    end
+
+    alias_method :current_length, :length
+
+    # The number of tasks in the queue awaiting execution.
+    #
+    # @return [Integer] the queue_length
+    def queue_length
+      mutex.synchronize { running? ? @queue.length : 666 }
+    end
+
+    # Returns an array with the status of each thread in the pool
+    #
+    def status
+      mutex.synchronize { @pool.collect { |worker| worker.status } }
+    end
+
+    # Number of tasks that may be enqueued before reaching `max_queue` and
+    # rejecting new tasks. A value of -1 indicates that the queue may grow
+    # without bound.
+    #
+    # @return [Integer] the remaining_capacity
+    def remaining_capacity
+      mutex.synchronize { @max_queue == 0 ? -1 : @max_queue - @queue.length }
+    end
+
+    # Run on task completion.
+    #
+    # @!visibility private
+    def on_end_task
+      mutex.synchronize do
+        @completed_task_count += 1 #if success
+        break unless running?
+      end
+    end
+
+    # Run when a thread worker exits.
+    #
+    # @!visibility private
+    def on_worker_exit(worker)
+      mutex.synchronize do
+        @pool.delete(worker)
+        if @pool.empty? && !running?
+          stop_event.set
+          stopped_event.set
+        end
+      end
+    end
+
+    protected #      A T T E N Z I O N E   A R E A   P R O T E T T A
+
+    # @!visibility private
+    def execute(*args, &task)
+      if ensure_capacity?
+        @scheduled_task_count += 1
+        @queue << [args, task]
+      else
+        if @max_queue != 0 && @queue.length >= @max_queue
+          handle_fallback(*args, &task)
+        end
+      end
+      prune_pool
+    end
+
+    # @!visibility private
+    def shutdown_execution
+      if @pool.empty?
+        stopped_event.set
+      else
+        @pool.length.times { @queue << :stop }
+      end
+    end
+
+    # @!visibility private
+    def kill_execution
+      @queue.clear
+      drain_pool
+    end
+
+    # Check the thread pool configuration and determine if the pool
+    # has enought capacity to handle the request. Will grow the size
+    # of the pool if necessary.
+    #
+    # @return [Boolean] true if the pool has enough capacity else false
+    #
+    # @!visibility private
+    def ensure_capacity?
+      additional = 0
+      capacity   = true
+
+      if @pool.size < @min_length
+        additional = @min_length - @pool.size
+      elsif @queue.empty? && @queue.num_waiting >= 1
+        additional = 0
+      elsif @pool.size == 0 && @min_length == 0
+        additional = 1
+      elsif @pool.size  < @max_length || @max_length == 0
+        additional = 1
+      elsif @max_queue == 0 || @queue.size < @max_queue
+        additional = 0
+      else
+        capacity = false
+      end
+
+      additional.times do
+        @pool << create_worker_thread
+      end
+
+      if additional > 0
+        @largest_length = [@largest_length, @pool.length].max
+      end
+
+      capacity
+    end
+
+    # Scan all threads in the pool and reclaim any that are dead or
+    # have been idle too long. Will check the last time the pool was
+    # pruned and only run if the configured garbage collection
+    # interval has passed.
+    #
+    # @!visibility private
+    def prune_pool
+      if Garcon.monotonic_time - @gc_interval >= @last_gc_time
+        @pool.delete_if { |worker| worker.dead? }
+        # send :stop for each thread over idletime
+        @pool.select { |worker| @idletime != 0 &&
+          Garcon.monotonic_time - @idletime > worker.last_activity
+        }.each { @queue << :stop }
+        @last_gc_time = Garcon.monotonic_time
+      end
+    end
+
+    # Reclaim all threads in the pool.
+    #
+    # @!visibility private
+    def drain_pool
+      @pool.each { |worker| worker.kill }
+      @pool.clear
+    end
+
+    # Create a single worker thread to be added to the pool.
+    #
+    # @return [Thread] the new thread.
+    #
+    # @!visibility private
+    def create_worker_thread
+      wrkr = ThreadPoolWorker.new(@queue, self)
+      Thread.new(wrkr, self) do |worker, parent|
+        Thread.current.abort_on_exception = false
+        worker.run
+        parent.on_worker_exit(worker)
+      end
+      return wrkr
+    end
+  end
+end