Boost logo

Boost :

Subject: Re: [boost] [lock-free] CDS -yet another lock-free library
From: Khiszinsky, Maxim (Maxim.Khiszinsky_at_[hidden])
Date: 2010-03-29 01:55:12

> Have you considered using the proposed Boost.Atomic? This should
support more platforms.

> If there is something missing from Boost.Atomic that is needed for this
purpose, it would be useful to know about it.

Yes, I considered Boost.Atomic some time ago and I decided to implement separate atomics in the CDS library:

1. Not all processor architectures that I need are implemented in Boost.Atomic (maybe, today it is not right).

2. Function-based implementation of atomics produces non-optimal code in some cases. Consider the usual implementation of atomic with explicit memory ordering:
Static inline void store( atomic_t * pDest, atomic_t nVal, memory_order order )
   switch ( order ) {
      case memory_order_relaxed: *pDest = nVal; break ;
      case ...
      case ...
The problem is that the compiler (in some cases) generates case-based code when 'order' parameter is constant for caller:
   store( &myAtomic, 10, memory_order_relaxed) ;
in this case instead of ONE assembler store instruction the compiler may generate many branch instruction. It is not optimal :-(. And 99% of code with atomic primitives has *constant* memory_order parameter.

More optimized implementation of atomic is template-based:

Template <memory_order ORDER>
void store( atomic_t * pDest, atomic_t nVal ) ;
template <>
void store<memory_order_relaxed>( pDest, nVal )
   *pDest = nVal ;
And so on for each memory_order constant.
Template-based implementation is more optimized: the memory_order constant is a *compiler selector* to choose appropriate implementation. No compiler optimization required.

I think, the C++ Memory Model proposal implies significant support from C++ compiler for the best result. In fact, std::atomic should be the compiler intrinsic to generate optimal code.

Regards, Max

Boost list run by bdawes at, gregod at, cpdaniel at, john at