<?xml version="1.0" encoding="UTF-8"?>
<!-- Generated on Fri, 25 May 2012 16:52:25 -0700 -->
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <atom:link href="http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/feed/" rel="self" type="application/rss+xml" />
    <title>Intel Software Network Comments Feed</title>
    <link>http://software.intel.com/en-us/articles/single-producer-single-consumer-queue</link>
    <description></description>
    <language>en-us</language>
    <item>
      <title>By sb</title>
      <description><![CDATA[ I liked the store release / load_consume templates & their use, very elegant
but does this actually enQ & deQ?

Yes, ok , so it took me a while ;-)
You enQ onto the head_ & deQ off the tail_
I was rather expecting the reverse, like  people Q&#39;ing for theatre tickets
the head is in the theatre!

very, very elegant indeed
 ]]></description>
      <link>http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-9294</link>
      <pubDate>Thu, 27 Nov 2008 12:13:31 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-9294</guid>
    </item>
    <item>
      <title>By Dmitriy Vyukov</title>
      <description><![CDATA[ Thank you.
I am also thinking about posting eventcount algorithm, which can magically turn this non-blocking queue into blocking queue. Blocking in the sense that dequeue() will be blocking if there is no elements instead of returning false. Additional cost will be: MFENCE + single load + single conditional branching in enqueue(); nothing in dequeue(). Unfortunately it&#39;s impossible to implement blocking w/o MFENCE (which can be fairly costly) in enqueue().
 ]]></description>
      <link>http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-9464</link>
      <pubDate>Fri, 05 Dec 2008 10:28:39 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-9464</guid>
    </item>
    <item>
      <title>By trs</title>
      <description><![CDATA[ Thanks for this article, I'm curious, would also work on the MSVC compiler if I replace __memory_barrier() with _memoryBarrier()? I know on MSVC volatile implies a lot more then it might on the Intel compiler, although I'm not sure about the Intel compiler side. ]]></description>
      <link>http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-13337</link>
      <pubDate>Tue, 30 Dec 2008 10:21:12 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-13337</guid>
    </item>
    <item>
      <title>By Dmitriy Vyukov</title>
      <description><![CDATA[ Yes, on MSVC volatile is enough, so you can just remove __memory_barrier().
However, substitution for __memory_barrier() (i.e. full compiler fence) on MSVC is _ReadWriteBarrier(). ]]></description>
      <link>http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-16323</link>
      <pubDate>Fri, 16 Jan 2009 10:00:25 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-16323</guid>
    </item>
    <item>
      <title>By trs</title>
      <description><![CDATA[ Thanks for the response, works beautifully in my application generating mouse events in one thread, and passing them to a receiving thread for handling ]]></description>
      <link>http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-16524</link>
      <pubDate>Thu, 22 Jan 2009 19:54:56 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-16524</guid>
    </item>
    <item>
      <title>By Obal</title>
      <description><![CDATA[ Is this SMP safe? ]]></description>
      <link>http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-18021</link>
      <pubDate>Wed, 04 Feb 2009 10:26:13 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-18021</guid>
    </item>
    <item>
      <title>By Obal</title>
      <description><![CDATA[ Also, just wondering what the multiple producer XCHG implies? There is no implementation anywhere. It is also advertised as cheaper than CAS, but isn't that an implicit LOCk anyway..

 ]]></description>
      <link>http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-18022</link>
      <pubDate>Wed, 04 Feb 2009 10:28:01 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-18022</guid>
    </item>
    <item>
      <title>By Tom Pattson</title>
      <description><![CDATA[ For those interested in C# and .Net Parallel Extensions, it will include a ConcurrentQueue to solve the producer / consumer problem.
I found a good example of its implementation in the book C# 2008 and 2005 threaded programming (Gaston Hillar, packt publishing), http://www.amazon.co.uk/2008-2005-Threaded-Programming-Beginners/dp/1847197108/ref=pd_rhf_p_t_1
You can also check Microsoft documentation. However, the examples are not as real-life as the one I mention. I recommended that book in another post. ]]></description>
      <link>http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-18087</link>
      <pubDate>Thu, 05 Feb 2009 17:54:58 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-18087</guid>
    </item>
    <item>
      <title>By Dmitriy Vyukov</title>
      <description><![CDATA[ Yes, this is SMP safe. ]]></description>
      <link>http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-20407</link>
      <pubDate>Fri, 27 Feb 2009 01:27:49 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-20407</guid>
    </item>
    <item>
      <title>By Dmitriy Vyukov</title>
      <description><![CDATA[ You may see XCHG-based multi-producer queue here:
http://groups.google.com/group/lock-free/browse_frm/thread/55df71b87acb8201

Yes, it's some more scalable than CAS-based queues, because of (1) it's wait-free, (2) it doesn't require load of shared location before atomic RMW.
 ]]></description>
      <link>http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-20461</link>
      <pubDate>Sat, 28 Feb 2009 23:09:22 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-20461</guid>
    </item>
    <item>
      <title>By Obal</title>
      <description><![CDATA[ Thanks for the responses Dmitriy..

I was just trying to compile XCHG on VC9 and was aiming at what the implementation would be?

 ]]></description>
      <link>http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-24110</link>
      <pubDate>Sun, 10 May 2009 05:35:09 -0700</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-24110</guid>
    </item>
    <item>
      <title>By Dmitriy Vyukov</title>
      <description><![CDATA[ _InterlockedExchange/_InterlockedExchange64 from <intrin.h>
 ]]></description>
      <link>http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-24115</link>
      <pubDate>Sun, 10 May 2009 07:22:20 -0700</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-24115</guid>
    </item>
    <item>
      <title>By Jared White</title>
      <description><![CDATA[ Has anyone tested/ported this on Linux? ]]></description>
      <link>http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-31562</link>
      <pubDate>Fri, 25 Sep 2009 09:06:55 -0700</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-31562</guid>
    </item>
    <item>
      <title>By Frank</title>
      <description><![CDATA[ What's the licensing details with this code? Is it BSD?
Thanks!
Frank ]]></description>
      <link>http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-69722</link>
      <pubDate>Fri, 27 Jan 2012 06:19:52 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-69722</guid>
    </item>
    <item>
      <title>By  还是说Memory Model，gcc的__sync_synchronize真是太坑爹了！ &amp;raquo; snnn的blog</title>
      <description><![CDATA[ n/a ]]></description>
      <link>http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-69738</link>
      <pubDate>Sat, 28 Jan 2012 11:18:55 -0800</pubDate>
      <guid isPermaLink="true">http://software.intel.com/en-us/articles/single-producer-single-consumer-queue/#comment-69738</guid>
    </item>
  </channel></rss>
