<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
		>
<channel>
	<title>Comments on: Parallelize by process</title>
	<atom:link href="http://nutrun.com/weblog/parallelize-by-process/feed/" rel="self" type="application/rss+xml" />
	<link>http://nutrun.com/weblog/parallelize-by-process/</link>
	<description>nutrun</description>
	<lastBuildDate>Mon, 28 Jun 2010 07:35:37 +0000</lastBuildDate>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>http://wordpress.org/?v=3.0</generator>
	<item>
		<title>By: Ochronus</title>
		<link>http://nutrun.com/weblog/parallelize-by-process/comment-page-1/#comment-1221</link>
		<dc:creator>Ochronus</dc:creator>
		<pubDate>Mon, 27 Oct 2008 13:29:39 +0000</pubDate>
		<guid isPermaLink="false">http://nutrun.com/?p=189#comment-1221</guid>
		<description>Nice article (as usual), I&#039;ve created something similar (actually a ParallelRunner class), it has an init and run phase, and two overridable methods (success and failure) to handle the outcome of each separate process. Basically init fills an internal command array, and run then runs them in the background with a given concurrency. We use it from image downloading to feed processing. It&#039;s a lot more easier, since it separates the &quot;complicated&quot; concurrency handling routine from the worker code, and also there are no multithreading issues, plus every process is responsible for what it&#039;s doing 100%.</description>
		<content:encoded><![CDATA[<p>Nice article (as usual), I&#8217;ve created something similar (actually a ParallelRunner class), it has an init and run phase, and two overridable methods (success and failure) to handle the outcome of each separate process. Basically init fills an internal command array, and run then runs them in the background with a given concurrency. We use it from image downloading to feed processing. It&#8217;s a lot more easier, since it separates the &#8220;complicated&#8221; concurrency handling routine from the worker code, and also there are no multithreading issues, plus every process is responsible for what it&#8217;s doing 100%.</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: George Malamidis</title>
		<link>http://nutrun.com/weblog/parallelize-by-process/comment-page-1/#comment-1219</link>
		<dc:creator>George Malamidis</dc:creator>
		<pubDate>Sun, 26 Oct 2008 21:02:12 +0000</pubDate>
		<guid isPermaLink="false">http://nutrun.com/?p=189#comment-1219</guid>
		<description>Thanks for bringing this up, I&#039;ve amended the example to reflect your observation.</description>
		<content:encoded><![CDATA[<p>Thanks for bringing this up, I&#8217;ve amended the example to reflect your observation.</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: Shadowfiend</title>
		<link>http://nutrun.com/weblog/parallelize-by-process/comment-page-1/#comment-1216</link>
		<dc:creator>Shadowfiend</dc:creator>
		<pubDate>Sun, 26 Oct 2008 16:58:17 +0000</pubDate>
		<guid isPermaLink="false">http://nutrun.com/?p=189#comment-1216</guid>
		<description>Seems like your final example will have an issue with spawning more or less workers than the count necessarily allows for if access to the @worker_count variable isn&#039;t protected by a mutex. This would happen if two process completed at approximately the same time, causing their spawning threads to read the worker count simultaneously, then both increment it and save it back. This way, the worker count variable would only change by 1 when two processes actually terminated.

Also worth mentioning in these contexts is the MapReduce algorithm (http://en.wikipedia.org/wiki/MapReduce) and Ruby implementations like Skynet (http://skynet.rubyforge.org/).</description>
		<content:encoded><![CDATA[<p>Seems like your final example will have an issue with spawning more or less workers than the count necessarily allows for if access to the @worker_count variable isn&#8217;t protected by a mutex. This would happen if two process completed at approximately the same time, causing their spawning threads to read the worker count simultaneously, then both increment it and save it back. This way, the worker count variable would only change by 1 when two processes actually terminated.</p>
<p>Also worth mentioning in these contexts is the MapReduce algorithm (<a href="http://en.wikipedia.org/wiki/MapReduce" rel="nofollow">http://en.wikipedia.org/wiki/MapReduce</a>) and Ruby implementations like Skynet (<a href="http://skynet.rubyforge.org/" rel="nofollow">http://skynet.rubyforge.org/</a>).</p>
]]></content:encoded>
	</item>
</channel>
</rss>
