Interlocked operations in user-mode

Question

Hi, I understand there isn't a interface for interlocked operations in user-mode.
I would appreciate any help on how to write an implementation by myself. This help should
also include how to compile assembler files in SOLARIS , or how to inline assembler in the
C sources themself.
Note that the compiler is GCC
Thanks!!!

Answer 1

>
I'm not sure I agree with this - the canonical example
of where atomic integer operations provide the "one
true way" is reference counting. I tend to agree with you here - indeed, for high-granularity objects even 8-byte light-weight mutex would be a significant penalty, and reference counting is indeed the natural place for interlocked
arithmetics. The point is, you probably do not want to have reference counting for small objects -
these days it might be cheaper to create multiple copies. Anyway, this has to do with design,
and good design should address the issue.
>
Similar discussions have been taking place in other
threads on other forums. The general feeling seems to
be suprise that interlocked integer operations are not
part of the solaris ABI, though the existence of
<sys/atomic.h> shows that they are part of the kernel.
While we are at it, even the membar APIs in
<sys/atomic.h> have use in user mode application code
- esp. w.r.t the double-checked locking idiom when
implemented on a multi-processor machine. It is
impossible, even with volatile, to ensure that double
checked locking will work on an SMP machine without
inserting memory barriers. Furthermore, even if it is
true that 99.9% of the cases are handled with the
existing threads library, that is not a sufficient
reason to exclude a well known and widely used
synchronization primitive from user mode. It is clear
that users of solaris, both on sparc and intel, want a
standardized user-mode atomic integer operations API.
Perhaps just a user level implementation of
<sys/atomic.h> would do.Once again, I would probably agree with the argument - provided, we are talking about single
platform implementation. Unfortunately enough, interlocked operations aren't part of any standard,
so there is no way to create any platform-independent solution (unless one wants to use
concurrency-supportive languages like Ada 95).
I'd vote for inclusion of interlocked primitives into POSIX standard - then it will become mandatory
for the platform vendors... I doubt, however, whether Micro$oft would support this gracefully - so
far they have screwed up everything they've ever touched... :(