peach 0.2

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2008 Ben Hughes
+
+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

@@ -0,0 +1,22 @@
+Parallel Each  (for ruby with threads) 
+
+It is pretty common to have iterations over Arrays that can be safely run in parallel. With multicore chips becoming pretty common, single threaded processing is about as cool as Pog. Unfortunately, standard Ruby hates real threads pretty hardcore at the present time; however, for some ruby projects alternate VMs like  JRuby do give multicores some lovin'. Peach exists to make this power simple to use with minimal code changes. 
+
+Functions like map, each, and delete_if are often used in a functional, side-effect free style. If the operation in the block is computationally intense, performance can often be gained by multithreading the process. That's where Peach comes in. In the simplest case, you are one letter away from harnessing the power of parallelism and unlocking the secret of a guilt-free tan. At this stage, the goggles are purely optional. 
+
+Using Peach
+
+Suppose you are going about your day job hacking away at code for the WOPR when you stumble upon the code: 
+
+cities.each {|city| thermonuclear_war(city)}
+        
+Clearly, the only winning move is to declare war in parallel. With Peach, the new code is: 
+require 'peach'
+
+cities.peach {|city| thermonuclear_war(city)}
+        
+ Requiring peach.rb monkey patches Array into submission. Currently Peach provides peach, pmap, and pdelete_if. Each of these functions takes an optional argument n, which represents the desired number of worker threads with the default being one thread per Array element. For cheaper operations on a large number of elements, you probably want to set n to something reasonably low. 
+
+(0...10000).to_a.pmap(4) {|x| process(x)}
+        
+ Constructing the threads and adding on a few layers of indirection does add a bit of overhead to the iteration especially on MRI. Keep this in mind and remember to benchmark when unsure. 

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+end

data/bn/peach_bn.rb

@@ -0,0 +1,57 @@
+#Benchmark for Peach <http://peach.rubyforge.org>
+#Count intrawiki links in wikipedia data
+
+require 'peach'
+require 'benchmark'
+require 'digest/md5'
+
+puts "PEACH BENCHMARK"
+puts "Wikipedia Processing"
+puts
+
+#Read a small slice of the Wikipedia XML file
+fn = "peach_bn_data.txt"
+puts "Reading in dataset #{fn}"
+puts "Dataset is #{File.size(fn)/1024} kb"
+dataset = ""
+puts Benchmark.measure("read dataset") { dataset = File.read(fn) }
+
+puts "Splitting dataset into articles"
+articles = []
+puts Benchmark.measure("split dataset") { 
+  articles = dataset.scan(/<text xml:space=\"preserve\">.*?<\/text>/m)
+  articles.delete_if {|x| /#redirect/i.match(x) }
+}
+puts "Found #{articles.size} articles"
+puts
+puts "BEGIN REAL BENCHMARK"
+puts
+puts "map:"
+links1 = []
+for i in (1...5)
+puts Benchmark.measure {
+  links1 = articles.map do |article|
+    article.scan(/\[\[[\w -']+?\]\]/m)
+    #.each do |link|
+    #  Digest::MD5.hexdigest(article)
+    #end
+  end
+}
+end
+puts "Found #{links1.flatten.size} links"
+puts
+puts "pmap:"
+links2 = []
+for i in (1...5)
+puts Benchmark.measure {
+  links2 = articles.pmap(6) do |article|
+    article.scan(/\[\[[\w -']+?\]\]/m)
+    #.each do |link| 
+    #  Digest::MD5.hexdigest(link)
+    #end
+  end
+}
+end
+puts "Found #{links2.flatten.size} links"
+p links2 - links1
+puts "END"

data/bn/peach_test.rb

@@ -0,0 +1,46 @@
+require 'peach'
+require 'benchmark'
+
+def fac(n)
+  if n == 0
+    return 1
+  else
+    n*fac(n-1)
+  end
+end
+
+
+puts "PEACH TEST"
+puts "each:"
+def each_test
+  (0...1000).to_a.sort_by{rand}.each do |x|
+    fac(x)
+  end
+end
+puts Benchmark.measure { each_test }
+
+puts "peach:"
+def peach_test
+  (0...1000).to_a.sort_by{rand}.peach(4) do |x|
+    fac(x)
+  end
+end
+puts Benchmark.measure { peach_test }
+
+puts "map:"
+def map_test
+  (0...1000).to_a.sort_by{rand}.map do |x|
+    fac(x)
+  end
+end
+puts Benchmark.measure { map_test }
+
+
+puts "pmap:"
+def pmap_test
+  (0...1000).to_a.sort_by{rand}.pmap(4) do |x|
+    fac(x)
+  end
+end
+puts Benchmark.measure { pmap_test }
+

data/lib/peach.rb

@@ -0,0 +1,46 @@
+module Peach
+  def peach(n = nil, &b)
+    peach_run(:each, b, n)
+  end
+
+  def pmap(n = nil, &b)
+    peach_run(:map, b, n)
+  end
+
+  def pselect(n = nil, &b)
+    peach_run(:select, b, n)
+  end
+
+
+
+  protected
+  def peach_run(meth, b, n = nil)
+    threads, results, result = [],[],[]
+    peach_divvy(n).each_with_index do |x,i|
+      threads << Thread.new { results[i] = x.send(meth, &b)}
+    end
+    threads.each {|t| t.join }
+    results.each {|x| result += x if x}
+    result
+  end
+  
+  def peach_divvy(n = nil)
+    return [] if size == 0
+
+    n ||= $peach_default_threads || size
+    n = size if n > size
+
+    lists = []
+
+    div = (size/n).floor
+    offset = 0
+    for i in (0...n-1)
+      lists << slice(offset, div)
+      offset += div
+    end
+    lists << slice(offset...size)
+    lists
+  end
+end
+
+Array.send(:include, Peach)

data/test/peach_test.rb

@@ -0,0 +1,56 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+require File.join(File.dirname(__FILE__), "..", "lib", "peach")
+
+class PeachTest < Test::Unit::TestCase
+  [:peach, :pmap, :pselect].each do |f|
+    context "Parallel function #{f}" do
+      normal_f = f.to_s[1..-1].to_sym
+
+      setup do
+        @data = [1, 2, 3, 5, 8]
+        @block = lambda{|i| i**2}
+      end
+      should "return the same result as #{normal_f}" do
+        assert_equal @data.send(normal_f, &@block),
+          @data.send(f, nil, &@block)
+      end
+    end
+  end
+
+  context "divvy" do
+    setup do
+      @data = [1, 2, 3, 4, 5]
+    end
+
+    context "on empty list" do
+      should "return empty list" do
+        assert_equal [], [].send(:peach_divvy)
+      end
+    end
+
+    context "when n is nil" do
+      should "put 1 element into each division" do
+        assert_equal @data.size, @data.send(:peach_divvy).size
+      end
+    end
+
+    context "when n is less than array size" do
+      should "put create n divisions" do
+        assert_equal 2, @data.send(:peach_divvy, 2).size
+      end
+
+      should "not lose any array elements" do
+        assert_equal @data.size, @data.send(:peach_divvy, 2).inject(0) {|sum, i| 
+          sum + i.size
+        }
+      end
+    end
+    
+    context "when n is greater than array size" do
+      should "only create 'array size' divisions" do
+        assert_equal @data.size, @data.send(:peach_divvy, 42).size
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,8 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+$:.unshift(File.dirname(__FILE__)) unless 
+  $:.include?(File.dirname(__FILE__)) || 
+    $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'

data/web/index.html

@@ -0,0 +1,128 @@
+<html>
+  <head>
+    <title>Peach - Parallel Each</title>
+    <style>
+      pre {
+        background-color: #f1f1f3;
+        color: #112;
+        padding: 10px;
+        font-size: 1.1em;
+        overflow: auto;
+        margin: 4px 0px;
+        width: 95%;
+      }
+
+
+
+      /* Syntax highlighting */
+      pre .normal {}
+      pre .comment { color: #005; font-style: italic; }
+      pre .keyword { color: #A00; font-weight: bold; }
+      pre .method { color: #077; }
+      pre .class { color: #074; }
+      pre .module { color: #050; }
+      pre .punct { color: #447; font-weight: bold; }
+      pre .symbol { color: #099; }
+      pre .string { color: #944; background: #FFE; }
+      pre .char { color: #F07; }
+      pre .ident { color: #004; }
+      pre .constant { color: #07F; }
+      pre .regex { color: #B66; background: #FEF; }
+      pre .number { color: #F99; }
+      pre .attribute { color: #5bb; }
+      pre .global { color: #7FB; }
+      pre .expr { color: #227; }
+      pre .escape { color: #277; }
+    </style>
+  </head>
+  <body style="background-color: #ecad27;">
+    <center><div style="border: dotted #000 1px; 
+      background-color: #fff;
+      width: 745px;
+      text-align: left;">
+      <img src="Peach.sketch.png" alt="Peach">
+      <div style ="padding: 0px 20px 20px 20px;">
+	<h1>Parallel Each <small><small>
+	      (for ruby with threads)
+        </small></small></h1>
+	<p>
+	It is pretty common to have iterations over Arrays that can be safely 
+	run in parallel.  With multicore chips becoming pretty common,
+	single threaded processing is about as cool as Pog.  Unfortunately,
+	standard Ruby hates real threads pretty hardcore at the present time;
+	however, for some ruby projects alternate VMs like
+        <a href="http://jruby.codehaus.org/" title="JRuby: Coolest Thing Ever">
+	  JRuby</a> do give multicores some lovin'.  <i>Peach</i> exists to 
+	make this power simple to use with minimal code changes.
+	</p>
+	<p>Functions like <tt>map</tt>, <tt>each</tt>, and <tt>delete_if</tt>
+	are often used in a functional, side-effect free style.  If the
+	operation in the block is computationally intense, performance can 
+	often be gained by multithreading the process. That's where 
+	<i>Peach</i> comes in. In the simplest case, you are one letter away
+	from harnessing the power of parallelism and unlocking the secret of
+	a guilt-free tan.  At this stage, the goggles are purely optional.
+	</p>
+	<h2>Using Peach</h2>
+	<p>Suppose you are going about your day job hacking away at code for
+	the <a href="http://en.wikipedia.org/wiki/WOPR">WOPR</a> when you
+	stumble upon the code:
+	</p>
+	<pre><span class=ident>cities</span><span class=punct>.</span><span class=ident>each</span> <span class=punct>{|</span><span class=ident>city</span><span class=punct>|</span> <span class=ident>thermonuclear_war</span><span class=punct>(</span><span class=ident>city</span><span class=punct>)}</span>
+	</pre>
+	<p>Clearly, the only winning move is to declare war in parallel.  With
+	<i>Peach</i>, the new code is:
+	<pre>
+<span class="ident">require</span> <span class="punct">'</span><span class="string">peach</span><span class="punct">'</span>
+
+<span class=ident>cities</span><span class=punct>.</span><span class=ident>peach</span> <span class=punct>{|</span><span class=ident>city</span><span class=punct>|</span> <span class=ident>thermonuclear_war</span><span class=punct>(</span><span class=ident>city</span><span class=punct>)}</span>
+	</pre>
+	<p>
+	Requiring peach.rb monkey patches Array into submission.
+	Currently <i>Peach</i> provides <tt>peach</tt>, <tt>pmap</tt>, and
+	<tt>pdelete_if</tt>.  Each of these functions takes an optional
+	argument <i>n</i>, which represents the desired number of worker 
+	threads with the default being one thread per Array element.  For
+	cheaper operations on a large number of elements, you probably want
+	to set <i>n</i> to something reasonably low.
+	</p>
+	<pre><span class="punct">(</span><span class="number">0</span><span class="punct">...</span><span class="number">10000</span><span class="punct">).</span><span class="ident">to_a</span><span class="punct">.</span><span class="ident">pmap</span><span class="punct">(</span><span class="number">4</span><span class="punct">)</span> <span class="punct">{|</span><span class="ident">x</span><span class="punct">|</span> <span class="ident">process</span><span class="punct">(</span><span class="ident">x</span><span class="punct">)}</span>
+	</pre>
+	<p>
+	Constructing the threads and adding on a few layers of indirection does
+	add a bit of overhead to the iteration especially on MRI. Keep this in
+        mind and remember to benchmark when unsure.
+        <h3>Syntax (without all the words)</h3>
+<pre><span class="ident">require</span> <span class="punct">'</span><span class="string">peach</span><span class="punct">'</span>
+
+<span class="punct">[</span><span class="number">1</span><span class="punct">,</span><span class="number">2</span><span class="punct">,</span><span class="number">3</span><span class="punct">,</span><span class="number">4</span><span class="punct">].</span><span class="ident">peach</span><span class="punct">{|</span><span class="ident">x</span><span class="punct">|</span> <span class="ident">f</span><span class="punct">(</span><span class="ident">x</span><span class="punct">)}</span> <span class="comment">#Spawns 4 threads, =&gt; [1,2,3,4]</span>
+<span class="punct">[</span><span class="number">1</span><span class="punct">,</span><span class="number">2</span><span class="punct">,</span><span class="number">3</span><span class="punct">,</span><span class="number">4</span><span class="punct">].</span><span class="ident">pmap</span><span class="punct">{|</span><span class="ident">x</span><span class="punct">|</span> <span class="ident">f</span><span class="punct">(</span><span class="ident">x</span><span class="punct">)}</span> <span class="comment">#Spawns 4 threads, =&gt; [f(1),f(2),f(3),f(4)]</span>
+<span class="punct">[</span><span class="number">1</span><span class="punct">,</span><span class="number">2</span><span class="punct">,</span><span class="number">3</span><span class="punct">,</span><span class="number">4</span><span class="punct">].</span><span class="ident">pdelete_if</span><span class="punct">{|</span><span class="ident">x</span><span class="punct">|</span> <span class="ident">x</span> <span class="punct">&gt;</span> <span class="number">2</span><span class="punct">}</span> <span class="comment">#Spawns 4 threads, =&gt; [3,4]</span>
+
+
+<span class="punct">[</span><span class="number">1</span><span class="punct">,</span><span class="number">2</span><span class="punct">,</span><span class="number">3</span><span class="punct">,</span><span class="number">4</span><span class="punct">].</span><span class="ident">peach</span><span class="punct">(</span><span class="number">2</span><span class="punct">){|</span><span class="ident">x</span><span class="punct">|</span> <span class="ident">f</span><span class="punct">(</span><span class="ident">x</span><span class="punct">)}</span> <span class="comment">#Spawns 2 threads, =&gt; [1,2,3,4]</span>
+<span class="punct">[</span><span class="number">1</span><span class="punct">,</span><span class="number">2</span><span class="punct">,</span><span class="number">3</span><span class="punct">,</span><span class="number">4</span><span class="punct">].</span><span class="ident">pmap</span><span class="punct">(</span><span class="number">2</span><span class="punct">){|</span><span class="ident">x</span><span class="punct">|</span> <span class="ident">f</span><span class="punct">(</span><span class="ident">x</span><span class="punct">)}</span> <span class="comment">#Spawns 2 threads, =&gt; [f(1),f(2),f(3),f(4)]</span>
+<span class="punct">[</span><span class="number">1</span><span class="punct">,</span><span class="number">2</span><span class="punct">,</span><span class="number">3</span><span class="punct">,</span><span class="number">4</span><span class="punct">].</span><span class="ident">pdelete_if</span><span class="punct">(</span><span class="number">2</span><span class="punct">){|</span><span class="ident">x</span><span class="punct">|</span> <span class="ident">x</span> <span class="punct">&gt;</span> <span class="number">2</span><span class="punct">}</span> <span class="comment">#Spawns 2 threads, =&gt; [3,4]</span>
+</pre>
+        <h2>FAQ</h2>
+        <p><b>Q: I use normal ruby (MRI 1.8 or 1.9), will Peach confer superpowers and great performance upon my code?</b><br/>
+        A: No, on MRI your code will be slightly slower because of the increased overhead for Thread creation.  MRI is singlethreaded so Peach will not make it magically parallel.</p>
+        <p><b>Q: Why should I switch to JRuby to get the benefits of Peach?</b><br/>
+        A: Switching to JRuby for code that needs better performance is a good idea even without Peach.  JRuby is insanely fast and a good idea.  The multithreading and ability to use this humble utility is just another feature.</p>
+        <p><b>Q: Benchmarks?</b><br/>
+        A: I am pretty bad at benchmarking code, but I do have a simple test comparing performance between <tt>map</tt> and <tt>pmap</tt> on MRI and JRuby.  Headius helped in the preparation of these materials.  <a href="http://pastie.caboo.se/177240">Check it out</a>.  JRuby on Java 1.6 is <a href="http://pastie.caboo.se/177263">even faster</a>.  If you come up with any benchmarks, do let me know.</p>
+
+	<h2>Eat a Peach</h2>
+	<p>
+        <i>Peach</i> is distributed as a gem from github, so:<br/>
+        <tt>gem install schleyfox-peach --source=http://gems.github.com</tt>.
+	<ul>
+	  <li>Project Page: <a href="http://rubyforge.org/projects/peach/">
+            RubyForge</a>, <a href="http://github.com/schleyfox/peach">Github</a></li>
+	</ul>
+	</p>
+      </div>
+    </div></center>
+  </body>
+</html>
+

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: peach
+version: !ruby/object:Gem::Version 
+  version: "0.2"
+platform: ruby
+authors: 
+- Ben Hughes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-05 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: 
+email: ben@pixelmachine.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- LICENSE
+- Rakefile
+- lib/peach.rb
+- bn/peach_bn.rb
+- bn/peach_test.rb
+- test/test_helper.rb
+- test/peach_test.rb
+- web/index.html
+- web/Peach.sketch.png
+has_rdoc: false
+homepage: http://peach.rubyforge.org
+post_install_message: 
+rdoc_options: []
+
+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: 
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Parallel Each and other parallel things
+test_files: []
+