dispatch 0.0.1pre

data/examples/sleeping_barber.rb

@@ -0,0 +1,19 @@
+# A GCD-based implementation of the sleeping barber problem:
+#   http://en.wikipedia.org/wiki/Sleeping_barber_problem
+#   http://www.madebysofa.com/#blog/the_sleeping_barber
+
+waiting_chairs = Dispatch::Queue.new('com.apple.waiting_chairs')
+semaphore = Dispatch::Semaphore.new(3)
+index = -1
+while true
+  index += 1
+  success = semaphore.wait(Dispatch::TIME_NOW)
+  if success != 0
+    puts "Customer turned away #{index}"
+    next
+  end
+  waiting_chairs.async do
+    semaphore.signal
+    puts "Shave and a haircut #{index}"
+  end
+end

data/lib/dispatch.rb

@@ -0,0 +1,22 @@
+# 
+# dispatch.rb - Grand Central Dispatch support library
+# 
+# Copyright (C) 2010  Apple, Inc.
+# 
+# == Overview ==
+#
+# Grand Central Dispatch (GCD) is a novel approach to multicore computing
+# first released in Mac OS X version 10.6 Snow Leopard.
+# The Dispatch module and associated classes (Queue, Group, Semaphore, Source)
+# in MacRuby core provides a simple wrapping on top of the libdispatch C API.
+# This library provides higher-level services and convenience methods
+# to make it easier for traditional Ruby programmers to add multicore support.
+
+libdir = File.expand_path(File.dirname(__FILE__))
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+require 'dispatch/source'
+require 'dispatch/queue'
+require 'dispatch/proxy'
+require 'dispatch/job'
+require 'dispatch/enumerable'

data/lib/dispatch/enumerable.rb

@@ -0,0 +1,108 @@
+# Additional parallel operations for any object supporting +each+
+
+module Dispatch
+  class Queue
+    def fake_apply(n, &block)
+      g = Dispatch::Group.new
+      n.times do |i|
+        async(g) { block.call(i) }
+      end
+      g.wait
+    end
+  end
+end
+
+
+class Integer
+  # Applies the +&block+ +Integer+ number of times in parallel
+  # -- passing in stride (default 1) iterations at a time --
+  # on a concurrent queue of the given (optional) +priority+
+  # 
+  #   @sum = 0
+  #   10.p_times(3) { |j| @sum += j }
+  #   p @sum # => 55
+  #
+  def p_times(stride=1, priority=nil, &block)
+    n_times = self.to_int
+    q = Dispatch::Queue.concurrent(priority)
+    return q.apply(n_times, &block) if stride == 1
+    
+    n_strides = (n_times / stride).to_int
+    block_from = Proc.new do |j0|
+      lambda { |j| block.call(j0+j) }
+    end
+    q.fake_apply(n_strides) { |i| stride.times &block_from.call(i*stride) }
+    # Runs the remainder (if any) sequentially on the current thread
+    (n_times % stride).times &block_from.call(n_strides*stride)
+  end
+end
+
+module Enumerable
+
+  # Parallel +each+
+  def p_each(stride=1, priority=nil,  &block)
+    ary = self.to_a
+    ary.count.p_times(stride, priority) { |i| block.call(ary[i]) }
+  end
+
+  # Parallel +each+
+  def p_each_with_index(stride=1, priority=nil,  &block)
+    ary = self.to_a
+    ary.count.p_times(stride, priority) { |i| block.call(ary[i], i) }
+  end
+
+  # Parallel +collect+
+  # Results match the order of the original array
+  def p_map(stride=1, priority=nil,  &block)
+    @p_map_result = Dispatch::Proxy.new([])
+    @p_map_result_q ||= Dispatch::Queue.for(@p_map_result)
+    @p_map_result_q.sync do
+      self.p_each_with_index(stride, priority) { |obj, i| @p_map_result[i] = block.call(obj) }
+    end
+    @p_map_result.__value__
+  end
+
+  # Parallel +collect+ plus +inject+
+  # Accumulates from +initial+ via +op+ (default = '+')
+  # Note: each object can only run one p_mapreduce at a time
+  def p_mapreduce(initial, op=:+, stride=1, priority=nil, &block)
+    # Check first, since exceptions from a Dispatch block can act funky 
+    raise ArgumentError if not initial.respond_to? op
+    @mapreduce_q ||= Dispatch::Queue.for(self)
+    @mapreduce_q.sync do # in case called more than once at a time
+      @mapreduce_result = initial
+      q = Dispatch::Queue.for(@mapreduce_result)
+      self.p_each(stride, priority) do |obj|
+        val = block.call(obj)
+        q.async { @mapreduce_result = @mapreduce_result.send(op, val) }
+      end
+      q.sync {}
+      return @mapreduce_result
+    end
+  end
+
+  # Parallel +select+; will return array of objects for which
+  # +&block+ returns true.
+  def p_find_all(stride=1, priority=nil,  &block)
+    found_all = Dispatch::Proxy.new([])
+    self.p_each(stride, priority) { |obj| found_all << obj if block.call(obj) }
+    found_all.__value__
+  end
+
+  # Parallel +detect+; will return -one- match for +&block+
+  # but it may not be the 'first'
+  # Only useful if the test block is very expensive to run
+  # Note: each object can only run one p_find at a time
+  def p_find(stride=1, priority=nil,  &block)
+    @find_q ||= Dispatch::Queue.for(self)
+    @find_q.sync do 
+      @find_result = nil
+      q = Dispatch::Queue.for(@find_result)
+      self.p_each(stride, priority) do |obj|
+        q.async { @find_result = obj } if @find_result.nil? and block.call(obj)
+      end
+      q.sync {}
+      return @find_result
+    end
+  end
+end

data/lib/dispatch/job.rb

@@ -0,0 +1,52 @@
+module Dispatch
+  
+  # Track completion and return values of asynchronous requests
+  # Duck-type +join+ and +value+ from +Thread+
+  class Job  
+    # Create a Job that asynchronously dispatches the block 
+    attr_reader :group, :values
+    
+    def initialize(queue = Dispatch::Queue.concurrent, &block)
+      @queue = queue
+      @group = Group.new
+      @values = synchronize([])
+      add(&block) if not block.nil?
+    end
+    
+    def synchronize(obj)
+      Dispatch::Proxy.new(obj, @group)
+    end
+    
+    # Submit block as part of the same dispatch group
+    def add(&block)
+      @queue.async(@group) { @values << block.call }      
+    end
+  
+    # Wait until execution has completed.
+    # If a +block+ is passed, invoke that asynchronously
+    # on the specified +queue+ (or else the default queue).
+    def join(queue = Dispatch::Queue.concurrent, &block)
+      return group.wait if block.nil?
+      group.notify(queue) { block.call } 
+    end
+  
+    # Wait then return the next value; note: only ordered if a serial queue
+    # If a +block+ is passed, invoke that asynchronously with the value
+    # on the specified +queue+ (or else the default queue).
+    def value(queue = Dispatch::Queue.concurrent, &block)
+      return group.notify(queue) { block.call(result) } if not block.nil?
+      group.wait
+      return result
+    end
+
+    alias_method :sync, :synchronize
+
+    private
+    
+    # Remove and return the first value    
+    def result
+       @values[-1]
+    end
+    
+  end
+end

data/lib/dispatch/proxy.rb

@@ -0,0 +1,49 @@
+require 'delegate'
+
+module Dispatch
+  # Serialize or asynchronize access to a delegate object.
+  # Forwards method invocations to the passed object via a private serial queue, 
+  # and can call back asynchronously if given a block
+  #
+  class Proxy < SimpleDelegator
+    
+    attr_accessor :__group__, :__queue__, :__sync__
+    
+    # Create Proxy to wrap the given +delegate+,
+    # optionally specify +group+ and +queue+ for asynchronous callbacks
+    def initialize(delegate, group=Group.new, queue=Dispatch::Queue.concurrent)
+      super(delegate)
+      @__serial__ = Dispatch::Queue.for(self)
+      @__group__ = group
+      @__queue__ = queue
+      @__retval__ = nil
+    end
+
+    # Call methods on the +delegate+ object via a private serial queue
+    # Returns asychronously if given a block; else synchronously
+    #
+    def method_missing(symbol, *args, &block)
+      if block.nil? then
+        @__serial__.sync { @__retval__ = __getobj__.__send__(symbol,*args) }
+        return @__retval__
+      end
+      queue = @__queue__ # copy in case it changes while in flight
+      @__serial__.async(@__group__) do
+        retval = __getobj__.__send__(symbol, *args)
+        queue.async(@__group__) { block.call(retval) }
+      end
+    end
+
+    # Wait until the internal private queue has completed pending executions
+    def __wait__
+      @__serial__.sync { }
+    end
+    
+    # Return the +delegate+ object after waiting
+    def __value__
+      __wait__
+      __getobj__
+    end
+    
+  end
+end

data/lib/dispatch/queue.rb

@@ -0,0 +1,34 @@
+# Adds convenience methods to Queues
+
+module Dispatch
+  class Queue
+
+    # Returns a mostly unique reverse-DNS-style label based on
+    # the ancestor chain and ID of +obj+ plus the current time
+    # 
+    #   Dispatch::Queue.labelize(Array.new)
+    #   => enumerable.array.0x2000cc2c0.1265915278.97557
+    #
+    def self.labelize(obj)
+      names = obj.class.ancestors[0...-2].map {|a| a.to_s.downcase}
+      label = names.uniq.reverse.join(".")
+      "#{label}.0x%x.#{Time.now.to_f}" % obj.object_id
+    end
+
+    # Returns a new serial queue with a unique label based on +obj+
+    # Typically used to serialize access to that object
+    #
+    #   a = Array.new
+    #   q = Dispatch::Queue.for(a)
+    #   q.async { a << 2 }
+    #
+    def self.for(obj)
+      new(labelize(obj))
+    end
+    
+    # Wait until pending blocks have completed
+    def join
+      sync {}
+    end
+  end
+end

data/lib/dispatch/source.rb

@@ -0,0 +1,83 @@
+# Adds convenience methods to Queues for creating Sources
+
+module Dispatch
+  class Source
+    
+    @@events = {
+      exit:PROC_EXIT,
+      fork:PROC_FORK,
+      exec:PROC_EXEC,
+      signal:PROC_SIGNAL, 
+      
+      delete:VNODE_DELETE,
+      write:VNODE_WRITE, 
+      extend:VNODE_EXTEND, 
+      attrib:VNODE_ATTRIB, 
+      link:VNODE_LINK, 
+      rename:VNODE_RENAME, 
+      revoke:VNODE_REVOKE
+    }
+      
+    class << self
+          
+      def event2num(e)
+        return 0 if e.nil?
+        value = e.to_int rescue @@events[e.to_sym]
+        raise ArgumentError, "No event type #{e.inspect}" if value.nil?
+        value
+      end
+    
+      def events2mask(events)
+        mask = events.collect { |e| event2num(e) }.reduce(:|)
+      end
+
+      def data2events(bitmask)
+        @@events.collect { |k,v| k if (v & bitmask) > 0 }.compact
+      end
+
+      # Returns Dispatch::Source of type DATA_ADD
+      def add(queue = Dispatch::Queue.concurrent, &block)
+        Dispatch::Source.new(Dispatch::Source::DATA_ADD, 0, 0, queue, &block)
+      end
+
+      # Returns Dispatch::Source of type DATA_OR
+      def or(queue = Dispatch::Queue.concurrent, &block)
+        Dispatch::Source.new(Dispatch::Source::DATA_OR, 0, 0, queue, &block)
+      end
+
+      # Takes events: :delete, :write, :extend, :attrib, :link, :rename, :revoke
+      # Returns Dispatch::Source of type PROC
+      def process(pid, events, queue = Dispatch::Queue.concurrent, &block)
+        events = events2mask(events) if not events.respond_to? :to_int
+        Dispatch::Source.new(Dispatch::Source::PROC, pid, events, queue, &block)
+      end
+
+      # Returns Dispatch::Source of type SIGNAL
+      def signal(signal, queue = Dispatch::Queue.concurrent, &block)
+        signal = Signal.list[signal.to_s] if signal.to_i == 0
+        Dispatch::Source.new(Dispatch::Source::SIGNAL, signal, 0, queue, &block)
+      end
+
+      # Returns Dispatch::Source of type READ
+      def read(file, queue = Dispatch::Queue.concurrent, &block)
+        Dispatch::Source.new(Dispatch::Source::READ, file, 0, queue, &block)
+      end
+
+      # Returns Dispatch::Source of type WRITE
+      def write(file, queue = Dispatch::Queue.concurrent, &block)
+        Dispatch::Source.new(Dispatch::Source::WRITE, file, 0, queue, &block)
+      end
+
+      # Takes events: :exit, :fork, :exec, :signal
+      # Returns Dispatch::Source of type VNODE
+      def file(file, events, queue = Dispatch::Queue.concurrent, &block)
+        events = events2mask(events) if not events.respond_to? :to_int
+        Dispatch::Source.new(Dispatch::Source::VNODE, file, events, queue, &block)
+      end
+
+      def periodic(seconds, queue = Dispatch::Queue.concurrent, &block)
+        Dispatch::Source.timer(0, seconds, 0, queue, &block)
+      end
+    end
+  end
+end

data/lib/dispatch/version.rb

@@ -0,0 +1,3 @@
+module Dispatch
+  VERSION = "0.0.1pre"
+end

data/spec/enumerable_spec.rb

@@ -0,0 +1,188 @@
+require "spec_helper"
+
+if MACOSX_VERSION >= 10.6
+  describe "parallel loop" do
+    
+    describe :Integer do
+      describe :p_times do
+        before :each do
+          @count = 4
+          @ary = Array.new
+          @p_ary = Dispatch::Proxy.new []
+        end
+
+        it "runs the block that many times" do
+          @count.times { |j| @ary << 1 }
+          @count.p_times { |j| @p_ary << 1 }
+          @p_ary.size.should == @ary.size
+        end
+
+        it "runs the block passing the current index" do
+          @count.times { |j| @ary << j }
+          @count.p_times { |j| @p_ary << j}
+          @p_ary.sort.should == @ary
+        end
+
+        it "does not run the block if the count is zero" do
+          0.p_times { |j| @ary << 1 }
+          @ary.size.should == 0
+        end
+
+        it "properly combines blocks with even stride > 1" do
+          @count.times { |j| @ary << j }
+          @count.p_times(2) { |j| @p_ary << j}
+          @p_ary.sort.should == @ary
+        end
+
+        it "properly combines blocks with uneven stride" do
+          @count.times { |j| @ary << j }
+          @count.p_times(3) { |j| @p_ary << j}
+          @p_ary.sort.should == @ary
+        end
+
+        it "properly rounds stride fraction of 0.5" do
+          6.times { |j| @ary << j }
+          6.p_times(4) { |j| @p_ary << j}
+          @p_ary.sort.should == @ary
+        end
+
+        it "properly rounds stride fraction > 0.5" do
+          7.times { |j| @ary << j }
+          7.p_times(4) { |j| @p_ary << j}
+          @p_ary.sort.should == @ary
+        end
+      end
+    end
+
+    describe "Enumerable" do
+      before :each do
+        @rng = (1..3)
+        @ary = @rng.to_a
+      end
+
+      describe :p_each do
+        it "exists on objects that support Enumerable" do
+          @ary.respond_to?(:p_each).should == true
+          @rng.respond_to?(:p_each).should == true
+        end
+
+        it "should behave like each" do
+          @ary1 = 0
+          @ary.each {|v| @ary1 << v*v}
+          @ary2 = 0
+          @q = Dispatch::Queue.for(@ary2)
+          @ary.p_each {|v| temp = v*v; @q.sync {@ary2 << temp} }
+          @ary2.should == @ary1
+        end
+
+        it "should work with ranges" do
+          @ary1 = 0
+          @ary.each {|v| @ary1 << v*v}
+          @ary2 = 0
+          @q = Dispatch::Queue.for(@ary2)
+          @rng.p_each {|v| temp = v*v; @q.sync {@ary2 << temp} }
+          @ary2.should == @ary1
+        end
+
+        it "should execute concurrently" do
+          t0 = Time.now
+          @ary.p_each {|v| sleep v/100.0}
+          t1 = Time.now
+          t_total = @ary.inject(0) {|a,b| a + b/100.0}
+          (t1-t0).to_f.should < t_total
+        end
+      end
+
+      describe :p_each_with_index do
+        it "exists on objects that support Enumerable" do
+          @ary.respond_to?(:p_each).should == true
+        end
+
+        it "should behave like each_with_index" do
+          @ary1 = 0
+          @ary.each_with_index {|v, i| @ary1 << v**i}
+          @ary2 = 0
+          @q = Dispatch::Queue.for(@ary2)
+          @ary.p_each_with_index {|v, i| temp = v**i; @q.sync {@ary2 << temp} }
+          @ary2.should == @ary1
+        end
+      end
+
+      describe :p_map do
+        it "exists on objects that support Enumerable" do
+          @ary.respond_to?(:p_map).should == true
+        end
+
+        it "should behave like map" do
+          map1 = @ary.map {|v| v*v}
+          map2 = @ary.p_map {|v| v*v}
+          map2.should == map1
+        end
+
+        it "should stride safely" do
+          map1 = @ary.map {|v| v*v}
+          map2 = @ary.p_map(2) {|v| v*v}
+          map2.should == map1
+        end
+      end
+
+      describe :p_mapreduce do
+        it "exists on objects that support Enumerable" do
+          @ary.respond_to?(:p_mapreduce).should == true
+        end
+
+        it "should behave like an unordered map" do
+          map1 = @ary.map {|v| v*v}
+          map2 = @ary.p_mapreduce([]) {|v| [v*v]}
+          map2.sort.should == map1
+        end
+
+        it "should accumulate any object that takes :+ " do
+          map1 = @ary.map {|v| "%x" % (10+v)}
+          map2 = @ary.p_mapreduce("") {|v| "%x" % (10+v)}   
+          map1.each do |s|
+            map2.index(s).should_not == nil
+          end
+        end
+
+        it "should allow custom accumulator methods" do
+          map1 = @ary.map {|v| v**2}
+          sum1 = map1.inject(0) {|s,v| s | v}
+          sum2 = @ary.p_mapreduce(0, :|) {|v| v**2}   
+          sum2.should == sum1
+        end
+      end
+
+      describe :p_find_all do
+        it "exists on objects that support Enumerable" do
+          @ary.respond_to?(:p_find_all).should == true
+        end  
+
+        it "should behave like find_all" do
+          found1 = @ary.find_all {|v| v.odd?}
+          found2 = @ary.p_find_all {|v| v.odd?}
+          found2.sort.should == found1
+        end
+      end
+
+      describe :p_find do
+        it "exists on objects that support Enumerable" do
+          @ary.respond_to?(:p_find).should == true
+        end  
+
+        it "returns nil if nothing found" do
+          found2 = @ary.p_find {|v| false}
+          found2.should.nil?
+        end
+
+        it "returns one element that matches the condition" do
+          found1 = @ary.find_all {|v| v.odd?}
+          found2 = @ary.p_find {|v| v.odd?}
+          found2.should_not.nil?
+          found1.include? found2
+        end
+      end
+    end
+
+  end
+end