← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/atomics.h

  • Committer: Monty Taylor
  • Date: 2009-03-30 18:17:18 UTC
  • mto: (971.1.10 mordred)
  • mto: This revision was merged to the branch mainline in revision 970.
  • Revision ID: mordred@inaugust.com-20090330181718-jyt04pyzcvxs76iw
Replacd use of tbb:: namespace with drizzled::

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/atomics.h
23
23
 
24
24
#if defined(HAVE_LIBTBB)
25
25
# include <tbb/atomic.h>
 
26
/* We're actually using the TBB interface directly, but we don't want to tie
 
27
 * the code to a specific implementation. So suck the tbb:: stuff into the
 
28
 * drizzled namespace
 
29
 */
 
30
namespace drizzled {
 
31
  using namspace tbb;
 
32
};
26
33
#else
27
34
 
28
35
# if defined(__SUNPRO_CC)
35
42
#  define ATOMIC_TRAITS internal::pthread_traits
36
43
# endif
37
44
 
38
 
# include <pthread.h>
39
 
# include <drizzled/atomic/pthread_traits.h>
40
 
 
41
 
 
42
 
namespace tbb {
 
45
# if (SIZEOF_SIZE_T >= SIZEOF_LONG_LONG) || (!defined(HAVE_GCC_ATOMIC_BUILTINS) || !defined(__SUNPRO_CC))
 
46
#  include <pthread.h>
 
47
#  include <drizzled/atomic/pthread_traits.h>
 
48
# endif
 
49
 
 
50
 
 
51
namespace drizzled {
43
52
 
44
53
namespace internal {
45
54
 
138
147
struct atomic {
139
148
};
140
149
 
141
 
#define __TBB_DECL_ATOMIC(T)                                            \
 
150
#define __DRIZZLE_DECL_ATOMIC(T)                                        \
142
151
  template<> struct atomic<T>                                           \
143
152
  : internal::atomic_impl<T,T,ATOMIC_TRAITS<T,T> > {                    \
144
153
    atomic<T>() : internal::atomic_impl<T,T,ATOMIC_TRAITS<T,T> >() {}   \
146
155
  };
147
156
 
148
157
 
149
 
__TBB_DECL_ATOMIC(long)
150
 
__TBB_DECL_ATOMIC(unsigned long)
151
 
__TBB_DECL_ATOMIC(unsigned int)
152
 
__TBB_DECL_ATOMIC(int)
153
 
__TBB_DECL_ATOMIC(unsigned short)
154
 
__TBB_DECL_ATOMIC(short)
155
 
__TBB_DECL_ATOMIC(char)
156
 
__TBB_DECL_ATOMIC(signed char)
157
 
__TBB_DECL_ATOMIC(unsigned char)
158
 
__TBB_DECL_ATOMIC(bool)
 
158
__DRIZZLE_DECL_ATOMIC(long)
 
159
__DRIZZLE_DECL_ATOMIC(unsigned long)
 
160
__DRIZZLE_DECL_ATOMIC(unsigned int)
 
161
__DRIZZLE_DECL_ATOMIC(int)
 
162
__DRIZZLE_DECL_ATOMIC(unsigned short)
 
163
__DRIZZLE_DECL_ATOMIC(short)
 
164
__DRIZZLE_DECL_ATOMIC(char)
 
165
__DRIZZLE_DECL_ATOMIC(signed char)
 
166
__DRIZZLE_DECL_ATOMIC(unsigned char)
 
167
__DRIZZLE_DECL_ATOMIC(bool)
159
168
 
160
169
/* 32-bit platforms don't have a GCC atomic operation for 64-bit types,
161
170
 * so we'll use pthread locks to handler 64-bit types on that platforms
162
171
 */
163
172
#  if SIZEOF_SIZE_T >= SIZEOF_LONG_LONG
164
 
__TBB_DECL_ATOMIC(long long)
165
 
__TBB_DECL_ATOMIC(unsigned long long)
 
173
__DRIZZLE_DECL_ATOMIC(long long)
 
174
__DRIZZLE_DECL_ATOMIC(unsigned long long)
166
175
#  else
167
 
#   define __TBB_DECL_ATOMIC64(T)                                            \
 
176
#   define __DRIZZLE_DECL_ATOMIC64(T)                                   \
168
177
  template<> struct atomic<T>                                           \
169
 
  : internal::atomic_impl<T,T,internal::pthread_traits<T,T> > {                    \
170
 
    atomic<T>() : internal::atomic_impl<T,T,internal::pthread_traits<T,T> >() {}   \
 
178
  : internal::atomic_impl<T,T,internal::pthread_traits<T,T> > {         \
 
179
    atomic<T>()                                                         \
 
180
      : internal::atomic_impl<T,T,internal::pthread_traits<T,T> >() {}  \
171
181
    T operator=( T rhs ) { return store_with_release(rhs); }            \
172
182
  };
173
 
__TBB_DECL_ATOMIC64(long long)
174
 
__TBB_DECL_ATOMIC64(unsigned long long)
 
183
__DRIZZLE_DECL_ATOMIC64(long long)
 
184
__DRIZZLE_DECL_ATOMIC64(unsigned long long)
175
185
#  endif
176
186
 
177
187
}