Re: [boost] [lock-free] CDS -yet another lock-free library

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