<?xml version="1.0" encoding="UTF-8"?>
<!-- Generated on Wed, 25 Nov 2009 09:12:52 -0800 -->
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <atom:link href="http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/feed/" rel="self" type="application/rss+xml" />
    <title>Intel Software Network Comments feed</title>
    <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/feed/</link>
    <description></description>
    <language>en-us</language>
    <item>
      <title>By Pravas Ranjan Das</title>
      <description><![CDATA[ I just love your book database. I am a empolyeer on software company whol likes to keep track of the books I read. Yours is the sap software I have found that suits my needs exactly!&#34; yours is the first one that does everything I want easily. 

Cheers!
Pravas ]]></description>
      <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-8852</link>
      <pubDate>Tue, 04 Nov 2008 22:27:55 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-8852</guid>
    </item>
    <item>
      <title>By Sanjeev Kumar</title>
      <description><![CDATA[ I appriciate a lot of yours Research Paper of Designing Thread Application.But i would like to get an example of such kind of application which will better explain yours research paper.I hope you will attach/send (on my Email ID) at least one example of Designing Thread Application.

Warm Regards,
Sanjeev Kumar
smartsanjeev.mca@gmail.com
(+91)09868349905
 ]]></description>
      <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-8856</link>
      <pubDate>Wed, 05 Nov 2008 02:20:43 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-8856</guid>
    </item>
    <item>
      <title>By sunny0104</title>
      <description><![CDATA[ It feels good to read your papers,thank you for your nice work. ]]></description>
      <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-9312</link>
      <pubDate>Fri, 28 Nov 2008 18:31:23 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-9312</guid>
    </item>
    <item>
      <title>By naveen</title>
      <description><![CDATA[ i m very must intrusted in Parallel computing system as i m doing my Masters in Real Time Embedded Systems this above details are very helpful in better understanding multi-threaded information ]]></description>
      <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-9367</link>
      <pubDate>Tue, 02 Dec 2008 04:15:27 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-9367</guid>
    </item>
    <item>
      <title>By Saravana</title>
      <description><![CDATA[ Excellet tips for developer who works on SMP &#34;Symmetric Muti Processing&#34; and recently the treding changing with Parallel programming to improve the power efficiency on Smart devices.

Cheers!
Saravana
 ]]></description>
      <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-9368</link>
      <pubDate>Tue, 02 Dec 2008 06:40:58 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-9368</guid>
    </item>
    <item>
      <title>By mrajasekharababu@vit.ac.in</title>
      <description><![CDATA[ First Time, I am handling Multi-Core programming lab for M.Tech computer Science and Engineering students, If you have any better lab programs using openMP and PThreading, kindly post to my e.mail ID. ]]></description>
      <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-9588</link>
      <pubDate>Thu, 11 Dec 2008 04:12:34 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-9588</guid>
    </item>
    <item>
      <title>By shishir.hn</title>
      <description><![CDATA[ thanks ]]></description>
      <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-22833</link>
      <pubDate>Sat, 18 Apr 2009 07:56:29 -0700</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-22833</guid>
    </item>
    <item>
      <title>By Zaratustra</title>
      <description><![CDATA[ Wow! Would never figure that out ... what is that? analyse, design, implement, optimize ... 

but why not other way around?  ]]></description>
      <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-25905</link>
      <pubDate>Wed, 10 Jun 2009 22:13:46 -0700</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-25905</guid>
    </item>
    <item>
      <title>By Jose Jesus Ambriz Meza</title>
      <description><![CDATA[ This rules are simples and efficient. ]]></description>
      <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-28727</link>
      <pubDate>Wed, 29 Jul 2009 20:03:04 -0700</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-28727</guid>
    </item>
    <item>
      <title>By josevilleta</title>
      <description><![CDATA[ Great starting point advice...I will make sure my USC students take this into consideration. ]]></description>
      <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-28775</link>
      <pubDate>Thu, 30 Jul 2009 11:09:43 -0700</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-28775</guid>
    </item>
    <item>
      <title>By Kirke Bent</title>
      <description><![CDATA[ I understand the idea of preferring coarse grained parallelism to minimize overhead. However, is it possible to give some guidance on how small a fine grained chunk can be before overhead overwhelms savings from parallelism? If precise guidance isn't possible, maybe some rules of thumb?

Thanks ]]></description>
      <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-29286</link>
      <pubDate>Sun, 09 Aug 2009 06:24:02 -0700</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-29286</guid>
    </item>
    <item>
      <title>By Clay Breshears (Intel)</title>
      <description><![CDATA[ Kirke -

As you've already surmised, there may not be an easy answer to your question and it will likely depend upon the threading model that you are using.  I've seen numbers like 10000 (machine) instructions as the recommended lower limit to make concurrent computation worthwhile.  How does that translate into lines of source code?  Hard to say (without counting lines of compiled assembly language).  

The rule of thumb I've used it to test different sizes to determine at what point performance might begin to taper off significantly.  For example, a recursive execution (like Quicksort) that uses a task for each new recursive call shouldn't kep creating new tasks until the biter end.  Rather it should switch over to a serial solution when the data size reaches a certain size.  I would typically guess that size; and as long as my performance doesn't decrease I would try successively smaller threshholds (or increase the size until I started to see some positive performance).

--clay ]]></description>
      <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-29481</link>
      <pubDate>Wed, 12 Aug 2009 08:22:00 -0700</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-29481</guid>
    </item>
    <item>
      <title>By Parallel Programming Talk #47 &amp;#8211; Software Development for N-core Processing</title>
      <description><![CDATA[ n/a ]]></description>
      <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-31145</link>
      <pubDate>Wed, 16 Sep 2009 15:01:26 -0700</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-31145</guid>
    </item>
    <item>
      <title>By Steve Doyle</title>
      <description><![CDATA[ Nice, simple and practical rules!

On the discussion around "how small a fine grained chunk can be" ... the threading building blocks documentation call this the "grain size" and recommend a default grain size of 10000 machine instructions (as Clay mentions above). The TBB book has a nice discussion on this including some graphs showing the impact of grain size as it is adjusted. ]]></description>
      <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-31170</link>
      <pubDate>Thu, 17 Sep 2009 01:36:42 -0700</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-31170</guid>
    </item>
    <item>
      <title>By choubey</title>
      <description><![CDATA[ Nice  ! Clay , Desiging Threaded application very fine 8 rules. Execute anything  is not  operations  in parallel run .  Give full idea . Thanks. Yours Deep ]]></description>
      <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-31857</link>
      <pubDate>Wed, 30 Sep 2009 03:59:26 -0700</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-31857</guid>
    </item>
    <item>
      <title>By choubey</title>
      <description><![CDATA[ Good day !  Clay ,  Two directions use a project to  thread a serial code. It is serial code of bottom - up & top - down. Please send  idia. Thanks .  Yours Deep ]]></description>
      <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-31863</link>
      <pubDate>Wed, 30 Sep 2009 05:44:25 -0700</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-31863</guid>
    </item>
    <item>
      <title>By choubey</title>
      <description><![CDATA[ Happy day !  Clay , In the Analysis phase of  the Threading Methodology  we identify the segments of  our code that take most  execution time . Fine process it work. Thanks all.  Yours Deep ]]></description>
      <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-31868</link>
      <pubDate>Wed, 30 Sep 2009 06:18:55 -0700</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-31868</guid>
    </item>
    <item>
      <title>By choubey</title>
      <description><![CDATA[ Nice day !  Clay , Information for Desiging Threaded  application  rules give good idea.  To run those code portion in parallel . Fine subject. Thanks.  Yours Deep  ]]></description>
      <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-31870</link>
      <pubDate>Wed, 30 Sep 2009 07:06:18 -0700</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-31870</guid>
    </item>
    <item>
      <title>By Clay Breshears (Intel)</title>
      <description><![CDATA[ @Deep -  One caution: Even though you can find those parts of your code that take the most time to execute, this will not guarantee that those parts can be parallelized.  There may not be any independent computations (or computations that would require more synchronization than is worthwhile to overcome the dependencies).  This is Rule 1.  

Alternately, from Rule 2, you may need to put the parallelism higher in the call tree of the computationally intense portions of code.  For example, I've used a prime number finding code for illustration over the last few years.  Profiling the application shows that the most time is spent in the function that does brute force factoring.  However, we've seen that the average time spent in that function can be 3 ms.  Much too short to introduce parallelism within that function directly.  Of course, the loop that repeatedly calls the primality testing function is the perfect place for parallelism.  Each test is independent of any other test and dividing up the range of numbers to be tested for primality among separate threads incorporates the computationally intense part of the code in parallel execution.
 ]]></description>
      <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-31872</link>
      <pubDate>Wed, 30 Sep 2009 07:23:05 -0700</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-31872</guid>
    </item>
    <item>
      <title>By choubey</title>
      <description><![CDATA[ Nice day !   Clay ,  I  learn your super function thought .  Your One  caution  is very nice. Thanks. Yours Deep ]]></description>
      <link>http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-31893</link>
      <pubDate>Wed, 30 Sep 2009 09:59:35 -0700</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/8-simple-rules-for-designing-threaded-applications/#comment-31893</guid>
    </item>
  </channel></rss>