January 2010 - Boost - lists.preview.boost.org

[Boost.utility]
by Andrew Chinkoff 27 Jan '10

27 Jan '10

Having considered [ http://www.research.ibm.com/designpatterns/pubs/ph-jun96.txt] I propose singleton implementation. I had attached "singleton.hpp" to this letter. Below is the test program: #include <stdio.h> #include <singleton.hpp> class A : public boost::Singleton<A> { // // Only Singleton class can create and delete us! // SINGLETON_IS_MY_FRIEND; public: void foo(){ printf("foo!\n"); } A(){ printf("A()\n"); } ~A(){ printf("~A()\n"); } }; void main() { // It is not compiled: //A a = A::Instance(); // That is exactly as it should be used: A::Instance().foo(); } Test program outputs: A() foo! ~A() I suggest include "singleton.hpp" into "utility.hpp" header that it can be used along with: boost::noncopyable, etc.

14 67

[1.41.0] [filesystem] Undefined references to get_system_category and get_generic_category
by Richard Hadsell 27 Jan '10

27 Jan '10

I am trying to build some code using the 1.41.0 version of the filesystem library. It used to build with version 1.34.1. I am getting errors, when the linker fails to find boost::system::get_system_category and boost::system::get_generic_category. What do I need to do differently to find or build these functions? -- Dick Hadsell 203-992-6320 Fax: 203-992-6001 Reply-to: hadsell(a)blueskystudios.com Blue Sky Studios http://www.blueskystudios.com 1 American Lane, Greenwich, CT 06831-2560

2 2

Are any of these bugs _really_ show stoppers?
by Marshall Clow 27 Jan '10

27 Jan '10

There are 25 bugs in the Trac system which are marked as "showstopper". Are any of these really worth holding up the release for? (and if not, should we reclassify these bugs?) http://svn.boost.org/trac/boost/report/29 986 Problem building Python modules on boost 1.34.0 1215 Boost 1.34.1, mpl: Wrong workaround detection using MinGW32 (or.hpp, line #33)" 2411 bzip2_compressor does not work with filtering_istream,new,Bugs,Boost 1.37.0 2512 interval cosh: wrong result if interval contains 0 (but is not identical to [0,0]) 2513 rint not present in Visual Studio 2008 2164 locate_root wrong under CygWin 2797 Two problems with thread_specific_ptr 2255 Compilation error during arm cross compile - boost 1.36 2883 Boost::signals compile problem with GCC 3.4.5 2958 [patch] changes to make asio compile on vxWorks 2956 vxWorks POSIX quirks for date_time 583 Fixes for build on IBM pSeries for AIX and Linux 426 lambda vs pure virtual functions 3325 Limited support for mapping regions to specific addresses in Linux 738 Memory leaks with signal::connect? 3480 Build fails on Debian: 2.6.18-5-686-bigmem #1 SMP Tue Dec 18 22:34:10 UTC 2007 i686 GNU/Linux 3165 wrong project-config.jam generated for intel-linux 2955 [patch] recursive mutex impossible if pthread_mutexattr_settype not defined 1066 Patch to make Boost.Python compile on SunCC 2185 bjam hangs when building libs/python/examples/quickstart under MacOS X 3716 Application crash when using Boost.Python in a plug-in DLL for that application 3723 gzip_docompressor error - basic_array_source no putback member 2330 thread::interrupt() can be lost if condition_variable::wait() in progress 3735 thread_group::interrupt_all() is unreliable 2226 boost::thread 1.36.0 /clr Link Error LNK2022 Just asking.... -- Marshall P.S. I don't mind fixing 2512 and 2513 - and can do that for 1.43 if people don't want them in 1.42.

3 4

BoostCon Conference Hotel Now Accepting Reservations
by David Abrahams 26 Jan '10

26 Jan '10

Hello Boosters and former BoostCon attendees! The BoostCon website has been updated for 2010, registration is open, and the conference hotel is already prepared to start taking our reservations. If you are planning to go to Boostcon this year, I suggest you take a few minutes to register (http://www.boostcon.com/registration) and make your hotel reservation (http://www.boostcon.com/location/lodging) today. -- Dave Abrahams Meet me at BoostCon: http://www.boostcon.com BoostPro Computing http://www.boostpro.com

1 0

[chrono] v0.3.2 New frequency, lifetime and percentage stopwatch_accumulator features
by vicente.botet 26 Jan '10

26 Jan '10

Hi, I have update the Boost.Chrono library with some minor features, a lot of bug fixes, and started the tutorial with some examples of features interesting people since the last version. New Features: * Added overloading for operator/(Integer/Duration) (used to get the frequency) * Added frequency, lifetime and percentage to the stopwatch_accumulator. The default format is "%c times, sum%ss, min%ms, max%Ms, mean%as, frequency%fherzs, lifetime%ls, percentage=%p%\n", where %c : the counter of the number of times the pair start/stop has been called. %s : the sum of the samples of elapsed time between the call to start/stop. %m : the min of the samples of elapsed time between the call to start/stop. %M : the max of the samples of elapsed time between the call to start/stop. %a : the mean of the samples of elapsed time between the call to start/stop. %f : the frequency of calls to start. %l : the lifetime of the stopwatch_accumulator. %p : the percentage of time spent by this stopwatch respect to its lifetime. Bug Fixes * Specific formatters didn't work completly * Replace duration(0) by duration::zero() on template classes. * suspend didn't work: partial_ not initialized neither taken in account by the elapsed function. The library can be downloaded from http://www.boostpro.com/vault/index.php?action=downloadfile&filename=chrono… and the documentation is online on the sandbox http://svn.boost.org/svn/boost/sandbox/chrono/libs/chrono/doc/html/index.ht…. SVN repository http://svn.boost.org/svn/boost/sandbox/chrono. I would like to thanks particularly Andrew Chinkoff for his suggestion of the frequency feature and all those that have tried the library and reported the bugs they found, either on this ML or personally. I would really appreciate if people having the possibility to test on other platforms/compilers report me how the library works. As you can see the library is already on the review schedule, waiting for a review manager and a date for the review. I expect to add yet some features for the review release as thread clocks, and suspensible clocks i.e. clocks that can be suspended/resumed. Any idea for better naming the concepts/classes is welcome. Hoping this release works better for you, Vicente (See below the contents of preceding releases) ----- Original Message ----- From: "vicente.botet" <vicente.botet(a)wanadoo.fr> To: <boost-users(a)lists.boost.org>; <boost(a)lists.boost.org> Sent: Wednesday, January 20, 2010 11:02 PM Subject: [chrono] v0.3.1 Support for wide characters Hi, this new version includes: * Added support for wide characters on formatters. * Added chrono.hpp and stopwatches.hpp header files at the boost level. * Update of the doc taking care of preceding comments. Comments are welcome :) Best, Vicente ----- Original Message ----- From: "vicente.botet" <vicente.botet(a)wanadoo.fr> To: <boost(a)lists.boost.org>; <boost-users(a)lists.boost.org> Sent: Sunday, January 17, 2010 9:14 PM Subject: [chrono] v0.3 New Stopwatch Feature Hi, I'm pleased to announce the new version of the Boost.Chrono library. The implementaton is quite stable; the new interface could suffer of some modifications, renaming, ... as far as you submit some proposals. I would request a formal review soon and I will need a review manager. I know that review managers are hard to find, so if you are interested in the library, please the Review Wizards. The library can be downloaded from http://www.boostpro.com/vault/index.php?action=downloadfile&filename=chrono… and the documentation is online on the sandbox http://svn.boost.org/svn/boost/sandbox/chrono/libs/chrono/doc/html/index.ht…. I've tested it with gcc and MSVC. Previoous version of the library have been testted on Mac, but I'm not able to test this platform. Could someone check if there are some regressions on Mac? New Features: * Process cpu clocks * Independent process cpu clocks for real, user, system process CPU time * Global process cpu clock for real, user, system process CPU time * Stopwatch concept measuring elapsed time between different points in time associated to the operations start, stop, suspend and resume. * stopwatch is a model Stopwatch measuring the elapsed time between the start and the stop operations. * stopwatch_accumulator is a model Stopwatch allowing to accumulate several time samples and give the average, ... * Scoped helper classes allowing to pairwise start/stop operations, suspend/resume and resume/suspend a Stopwatch. * Stopwatch Formatter concept * stopwatch formatter "%ds\n" * stopwatch accumulator formatter "%c times, sum%ss, min%ms, max%Ms, mean%as\n" * time formatter "real %rs, cpu %cs (%p%), user %us, system %ss\n" * digital_time decomposition class separating days, hours,minutes,seconds, nanoseconds from any duration class (looking for a better name) * digital_time formatter "%d days(s) %h:%m:%s.%n\n" * stopwatch_reporter is a convenient generic class reporting elapsed time for the Stopwatch concept. * stopclock<Clock> shortcut stopwatch_reporter<stopwatch<Clcok>> * typeof registration for classes duration and time_point Depreceated Features: * The classes process_times, process_clock, process_timer, timer and run_timer are now deprecated as the preceding additions are more generic. However for backward compatibility they are preserved until inclusion of the library in Boost. Next follows the equivalences: timer<> ~ stopwatch<> process_timer ~ stopwatch<process_cpu_clock> run_timer ~ stopclock<> Bug Fixes * Try to correct warning C4251: 'boost::chrono::run_timer::m_format' : class 'std::basic_string<_Elem,_Traits,_Ax>' needs to have dll-interface to be used by clients of class 'boost::chrono::run_timer', by don't including inlines functions using the std::string m_format. For people that doesn't know it yet, Boost.Chrono library provides: * The C++0x Standard Library's common_type. * The C++0x Standard Library's compile-time rational arithmetic. * The C++0x Standard Library's time utilities, including: * Class template duration * Class template time_point * Clocks: * system_clock * monotonic_clock * high_resolution_clock * typeof registration for classes duration and time_point * Process clocks: * process_real_CPU_clocks, capturing real-CPU times. * process_user_CPU_clocks, capturing user-CPU times. * process_system_CPU_clocks, capturing system-CPU times. * process_cpu_clock, tuple-like class capturing at once real, user-CPU, and system-CPU times. * Stopwatches: * stopwatch, capturing elapsed Clock times. * stopwatch_accumulator, capturing cummulated elapsed Clock times. * scoped helper classes allowing to pairwise start/stop operations, suspend/resume and resume/suspend a Stopwatch. * Stopclocks or Stopwatch reporters: * stopwatch_reporter, convenient reporting of models of Stopwatch results. * stopclock<Clock> shortcut of stopwatch_reporter<stopwatch<Clock>> Best regards, _____________________ Vicente Juan Botet Escribá

2 2

floating point FUD
by Thomas Klimpel 25 Jan '10

25 Jan '10

Hi, Find attached a small test program that tries to highlight some of the "usual" floating point traps. The essence is the following small function that outputs the results of some "buggy" floating point logic. The rest is just setting up the environment so that the bugs actually get triggered. void buggy_function(double eps = 1e-13, int length = 3, double delta = 1 / 7.0) { using namespace std; double alpha = 1e-13; double beta = eps; double a = length * delta; double b = length * delta; vector<double> inverse; for (int i = 0; i < length; ++i) inverse.push_back(1.0/(2*i+1)); vector<double> sorted; for (int i = 0; i < length; ++i) sorted.push_back(inverse[i]*delta); double t = -delta*sorted.size(); double tt = -sorted.size()*delta; bool t_tt = (abs(t-tt) < eps); bool abs_t = (abs(t) == -t); double c = (1-alpha) * a + alpha * b; double d = (1-beta) * a + beta * b; bool a_c = (a == c); bool b_d = (b == d); vector<bool> equal; for (int i = 0; i < length; ++i) equal.push_back(inverse[i]*delta == sorted[i]); std::cout << "t_tt = " << t_tt << "\nabs_t = " << abs_t << "\na_c = " << a_c << "\nb_d = " << b_d << "\n"; std::cout << "equal = ["; for (int i = 0; i < length; ++i) std::cout << " " << equal[i]; std::cout << " ]\n"; } The hypothetical "naive" programmer might expect the output: t_tt = 1 abs_t = 1 a_c = 1 b_d = 1 equal = [ 1 1 1 ] However, the actual output is not only different from this, but also depends on the compiler, the compiler settings, the current configuration of the floating points unit and the actual headers included directly or indirectly by the compilation unit. g++ test_fp.cpp -g -Wall compiles without warning and executes with output: t_tt = 0 abs_t = 1 a_c = 1 b_d = 1 equal = [ 1 1 1 ] g++ test_fp.cpp -DNDEBUG -O2 -msse2 -Wall compiles without warning and executes with output: t_tt = 0 abs_t = 1 a_c = 1 b_d = 1 equal = [ 1 0 0 ] I created a new project with MSVC9. The debug version compiles with warnings for the things that go badly wrong and executes with output: t_tt = 0 abs_t = 0 a_c = 1 b_d = 1 equal = [ 1 1 1 ] set floating point unit to 'high' precision: t_tt = 0 abs_t = 0 a_c = 1 b_d = 1 equal = [ 1 1 1 ] The release version compiles with warnings for the things that go badly wrong and executes with output: t_tt = 0 abs_t = 0 a_c = 1 b_d = 1 equal = [ 1 1 1 ] set floating point unit to 'high' precision: t_tt = 0 abs_t = 0 a_c = 0 b_d = 1 equal = [ 1 0 0 ] In my case (see the background story below), it was actually the trap represented by the output "abs_t = 0" instead of "abs_t = 1" that caught me on linux64 but worked on win32. (It turned out difficult to reproduce this with gcc, so the test program reproduces this trap with MSVC, even so MSVC warns quite explicitly about it). I think it is a funny exercise to debug the test program and find out what actually goes wrong (which is especially funny since most traps only go wrong with compiler optimization turned on). Regards, Thomas ------------------------ The background story: The recent reviews of [Constrained Value], [Polygon] and [GGL] all featured interesting disagreements over floating point issues: http://lists.boost.org/Archives/boost/2008/12/145655.php http://lists.boost.org/Archives/boost/2008/12/145788.php http://lists.boost.org/Archives/boost/2009/03/149567.php http://lists.boost.org/Archives/boost/2009/08/155767.php http://lists.boost.org/Archives/boost/2009/11/158560.php (These were long threads with many messages and many participants, so please don't misinterpret my choice of unrepresentative messages as any form of statement.) Last Wednesday, I had to give an internal live demo of a feature I just finished. I had done the development mostly on win32, but I wanted to run the demo on linux64, to be able to show examples of realistic size (full chip...). While preparing the presentation, I was surprised to find the accuracy of the results significantly worse than I remembered from my previous tests. I repeated my previous tests on linux64, and found out that there was indeed a problem with my code on linux64. I did the demo on win32, but was asked after the presentation to send the source code to somebody from another group. So I spent most of the night trying to find the problem in my code. When I found out that some code with floating point driven logic (I had written years ago) to analytically integrate radial symmetric functions over rectangular domains was showing unexpected behavior, I decided to postpone the floating point fights with the compiler to the next day. I told this story the next day in a group meeting, and was confronted with much floating point FUD and unrealistic suggestions, basically boiling down to either not writing floating point driven logic in the first place, or commenting it in excessive detail. So I lost my temper and explained that it was difficult enough for me to write this code with floating point driven logic, and that anybody suggesting writing it without floating point driven logic should do so please, because I'm unable to do it. I have to admit that I read "What Every Computer Scientist Should Know About Floating-Point Arithmetic" only superficially: http://www.engrng.pitt.edu/hunsaker/3097/floatingpoint.pdf http://docs.sun.com/source/806-3568/ncg_goldberg.html I also have to admit that I write code with floating point driven logic from time to time in case it seems unavoidable to me, and that this code often has bugs that are only discovered months after the code is already finished. But I never found a bug in such code that would have been a fundamental problem with floating point, but always just the "usual" floating point traps I keep overlooking by mistake. Now somebody will probably suggest that I should at least document the "usual" floating point traps then. So I created the attached small test program showing the "usual" floating point traps I could still remember having overlooked at least once. It was actually more difficult than expected to arrange the code in a way that the bugs are really triggered for typically compiler settings of MSVC and gcc.

9 16

[Quickbook] Integrating Spirit docs
by Hartmut Kaiser 24 Jan '10

24 Jan '10

Hey, Not exactly a question for the main devel list, but I'm not sure, where its best to send it to... What do I need to do in order to integrate the Spirit docs (generated by Quickbook) with Boosts overall doc page (i.e. http://www.boost.org/doc/libs/1_41_0/doc/html/libraries.html)? Regards Hartmut --------------- Meet me at BoostCon www.boostcon.com

2 1

Re: [boost] RFC: Sequence Properties and Boost Algorithm/Functional
by Grant Erickson 24 Jan '10

24 Jan '10

On Fri, 22 Jan 2010 14:13:31 -0800 Jeffrey Hellrung <jhellrung(a)ucla.edu> wrote: On 1/23/10 12:35 AM, boost-request(a)lists.boost.org wrote: >> For a recent project, I needed to inquire about a sequence of objects and >> make a determination as to whether the sequences were: >> >> * Increasing >> * Strictly Increasing >> * Decreasing >> * Strictly Decreasing >> >> Looking through STL, Boost documentation, Boost sources and headers and the >> Boost mailing lists I was able to find neither an existing algorithm or >> stateful unary predicate functor for accomplishing this for a pair of input >> iterators. However, I was a bit surprised considering that this seems like a >> sequence property query that would tend to come up fairly often and serve a >> general utility. Did I just fail to form the proper search/query or am I >> overestimating the general utility? >> >> Is a smarter realization of this as an algorithm a potential candidate for >> boost::algorithm? > > Perhaps std::adjacent_find and std::less is all you need, e.g., to > determine if a sequence is decreasing? > > I.e., a sequence is decreasing iff all adjacent pairs of elements xi, > x[i+1] satisfies xi >= x[i+1] iff no adjacent pair of elements xi, > x[i+1] satisfies xi < x[i+1] (assuming that (!>=) == (<)). On Fri, 22 Jan 2010 15:24:32 -0800 Marshall Clow <mclow.lists(a)gmail.com> wrote: > I've got this floating around from a while back... > > [ examples omitted ] Marshall and Jeff: Thanks for the feedback. Marshall's feedback seems to indicate that, yes, there is likely general utility need for such functions and Jeff, you are correct that these algorithms are trivially composed from std::adjacent_find, std::not2 and std::{greater,less,greater_equal,less_equal}: namespace boost { namespace detail { template <typename ForwardIterator, typename BinaryPredicate> bool is_creasing(ForwardIterator first, ForwardIterator last, BinaryPredicate binary_pred) { return std::adjacent_find(first, last, std::not2(binary_pred)) == last; } } // namespace detail template <typename ForwardIterator> bool is_increasing(ForwardIterator first, ForwardIterator last) { typedef typename std::iterator_traits<ForwardIterator>:: value_type value_type; return detail::is_creasing(first, last, std::less_equal<value_type>()); } [ ... other three instances follow trivially ... ] } // namespace boost Unless there's any other feedback, I'll work on posting an implementation to Boost Vault. Regards, Grant

1 0

Re: [boost] MPL bitand.hpp and iso646.h on MSVC 2008
by Nelson, Erik - 2 24 Jan '10

24 Jan '10

After further research, I saw that this is a duplicate of very similar reports previously. I'm not sure if it's scheduled to be fixed, but it still seems to be a problem in boost v1.41 Thanks Erik

3 3

[lockfree::fifo] Review
by Andrew Venikov 24 Jan '10

24 Jan '10

I decided to start a new thread on this topic since the last thread on the same topic is pretty outdated and not everyone will see it. (you can disregard my reply to the previous thread as this one is more complete) First of all I think that having a library of lock-free algorithms/containers would be greatly beneficial to a great number of boost users. On the other hand, having implemented several lock-free algorithms, I know that it is notoriously hard to get them right. We'll need all the help we can get from knowledgeable people in the field. The implementation needs to be thoroughly reviewed. Let me give the first attempt at that. In this e-mail I'll be primarily concentrating on the algorithm correctness rather than the interface. First, let me start with the choice of the algorithm for the fifo queues: Magued Michael and Michael Scott's "Simple, Fast, and Practical Non-blocking and blocking concurrent queues". I really think it is the best choice. Having said that, however, I need to point out that there some inherent limitation in this algorithm. The first limitation is that you can't peek at the head of the queue without dequeueing the element first, hence you can't get an interface that is conformant with std::queue. But I truly believe that it will be the case with any lock-free queue implementation, hence we should abandon the hope of having a lock-free queue look the same as std::queue Second, this algorithm makes certain assumptions about the ability to access memory that has been freed. The algorithm can try to read memory that has been de-allocated. (See further down for description of how). Several debug implementations of malloc/free store every allocated element on one page and when the element is freed, the page is marked protected for both reading and writing. That means that this algorithm can only work with a subset of custom allocators. Your "free_list" for example can't work with it since it's possible for a node to be freed when you call "deallocate". The "caching_freelist" and "static_freelist" on the other hand work just fine because they never return the memory back to the system. Third, and the biggest limitation, is the algorithm's assumption that you can store a pointer to an element plus an ABA tag in a contiguous memory space that can be passed to a CAS instruction. I believe not all platforms provide a DCAS instruction, that's why you're trying to work around this issue by using "packed pointers", i.e. storing the ABA tag in the part of the pointer that presumably is never used. The problem with that, however, is that some libc implementations of malloc/free do use all the bits in the pointer for their own needs, so you can't assume that you can meddle with them. My experience with this algorithm shows that the safest approach is to use a pre-allocated array for the queue and replace pointers with indexes into the array. Assuming that the size of an index is sufficiently lower than the size of a pointer, you can use the remaining bits to store the ABA tag. This alleviates both point 2 and 3. This does mean however, that the queue can't have an unbound size, the size has to be specified during the queue instantiation. Fourth, on platforms where CAS is implemented using LL/SC (such as PowerPC and MIPS), it is possible to livelock. The problem with LL/SC on most platforms is that the write granulum for marking LL's address as "dirty" isn't just the memory pointed to by LL, but the whole cache line where the memory resides. On these platforms it is important to make sure that each "node" of the queue is located on a separate cache line. Here's the code of your enqueue: bool enqueue(T const & t) { node * n = alloc_node(t); if (n == NULL) return false; for (;;) { atomic_node_ptr tail (tail_); //1 read_memory_barrier(); //2 atomic_node_ptr next (tail->next); //3 if (likely(tail == tail_)) //4 { if (next.get_ptr() == 0) //5 { if ( tail->next.cas(next, n) )//6 { tail_.cas(tail, n); return true; } } else tail_.cas(tail, next.get_ptr()); } } } 1. You're missing write barrier after a call to alloc_node(). Rational: alloc_node sets the "next" pointer of the newly allocated node to NULL. That is a store to shared memory. Setting next pointer to NULL has to be observable to other threads BEFORE they observe the inserted node. If you don't insert a write barrier, it is possible for other threads to see the new element in the list before element's next pointer is initialized with NULL. 2. You've misplaced the read_barrier. Rational: Line 4 checks the validity of the load done on line 3. That means that the read_barrier should be between lines 3 and 4. If you don't have a read_barrier after loading *tail->next, then this load can happen after the load of tail_ on line 4, which defies the purpose of line 4. Here's a scenario that makes it clear: State: queue is well-formed and tail_ points to the last element. 1. Thread A executes line1. State: the queue is unchanged and Thread A has a local copy of tail_ 2. Since there's no read barrier after line 3, loads at lines 3 and 4 happen out-of-order. tail_ is pre-loaded for comparison at line 4. 3. Thread B removes the element pointed by tail_, advances tail_ further State: tail_ is advanced, the old element is removed and given back to the allocator. A's local copy of tail_ becomes stale. 4. Thread A executes line 3 State: A's copy of tail is stale. This copy is used to load memory that has been reclamed by the allocator and possibly modified. The value of the memory happens to be 0. 5. Thread A executes line 4. Since tail_ has been preloaded, line 4 succedes. 6. Line 5 succedes 7. Line 6 succedes. Boom: you've just modified a piece of memory not controlled by the queue. You still need to have a barrier between lines 1 and 3, but here only a data dependency barrier will suffice, which is a weaker form of a read barrier and on most all platforms is a no-op since data dependent loads can be handled by processors automatically. 3. Your tail_ and head_ should be volatile. Furthermore, the getters for you tagged_ptr (like get_ptr, operator->() and operator* ) should return pointers/references to volatile types. Rational: If your tail_ is not volatile, then the compiler is free to load head_ just once and line 4 effectively becomes a no-op. Here's code for your "dequeue": bool dequeue (T * ret) { for (;;) { atomic_node_ptr head (head_); //1 read_memory_barrier(); //2 atomic_node_ptr tail(tail_); //3 node * next = head->next.get_ptr(); //4 if (likely(head == head_)) //5 { if (head.get_ptr() == tail.get_ptr()) //6 { if (next == 0) return false; tail_.cas(tail, next); } else { *ret = next->data; //7 if (head_.cas(head, next)) //8 { dealloc_node(head.get_ptr()); //9 return true; } } } } } 1. Again, you need to put read_barrier between lines 4 and 5. Only data dependency barrier will suffice at line 2. 2. You need to add write barrier after line 7 for the same reason as in the enqueue. Hope this was descriptive, Andy Venikov.

10 64