← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/atomics.h

Remove PLUGIN and MODULES.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/atomics.h
31
31
#  define ATOMIC_TRAITS internal::pthread_traits
32
32
# endif
33
33
 
34
 
# if (SIZEOF_SIZE_T >= SIZEOF_LONG_LONG) || (!defined(HAVE_GCC_ATOMIC_BUILTINS) || !defined(__SUNPRO_CC))
 
34
# if (SIZEOF_SIZE_T >= SIZEOF_LONG_LONG) || (!defined(HAVE_GCC_ATOMIC_BUILTINS) || !defined(__SUNPRO_CC)) || defined(__ppc__)
35
35
#  include <pthread.h>
36
36
#  include <drizzled/atomic/pthread_traits.h>
37
37
# endif
45
45
template<typename I>            // Primary template
46
46
struct atomic_base {
47
47
  volatile I my_value;
 
48
  atomic_base() : my_value(0) {}
 
49
  virtual ~atomic_base() {}
48
50
};
49
51
 
50
52
template<typename I, typename D, typename T >
54
56
public:
55
57
  typedef I value_type;
56
58
 
 
59
  atomic_impl() : atomic_base<I>(), traits() {}
57
60
 
58
61
  value_type fetch_and_add( D addend )
59
62
  {
97
100
  }
98
101
 
99
102
public:
100
 
  value_type operator+=( D addend )
 
103
  atomic_impl<I,D,T>& operator+=( D addend )
101
104
  {
102
 
      return fetch_and_add(addend)+addend;
 
105
    fetch_and_add(addend)+addend;
 
106
    return *this;
103
107
  }
104
108
 
105
 
  value_type operator-=( D addend )
 
109
  atomic_impl<I,D,T>& operator-=( D addend )
106
110
  {
107
111
    // Additive inverse of addend computed using binary minus,
108
112
    // instead of unary minus, for sake of avoiding compiler warnings.
109
113
    return operator+=(D(0)-addend);
110
114
  }
111
115
 
112
 
  value_type operator++() {
 
116
  value_type increment() {
113
117
    return fetch_and_add(1)+1;
114
118
  }
115
119
 
116
 
  value_type operator--() {
 
120
  value_type decrement() {
117
121
    return fetch_and_add(D(-1))-1;
118
122
  }
119
123
 
120
 
  value_type operator++(int) {
121
 
    return fetch_and_add(1);
122
 
  }
123
 
 
124
 
  value_type operator--(int) {
125
 
    return fetch_and_add(D(-1));
126
 
  }
127
124
 
128
125
};
129
126
 
141
138
  template<> struct atomic<T>                                           \
142
139
  : internal::atomic_impl<T,T,ATOMIC_TRAITS<T,T> > {                    \
143
140
    atomic<T>() : internal::atomic_impl<T,T,ATOMIC_TRAITS<T,T> >() {}   \
144
 
    T operator=( T rhs ) { return store_with_release(rhs); }            \
 
141
    atomic<T>& operator=( T rhs ) { store_with_release(rhs); return *this; } \
145
142
  };
146
143
/* *INDENT-ON* */
147
144
 
161
158
 * so we'll use pthread locks to handler 64-bit types on that platforms
162
159
 */
163
160
/* *INDENT-OFF* */
164
 
#  if SIZEOF_SIZE_T >= SIZEOF_LONG_LONG
 
161
# if !defined(__ppc__) && (defined(_INT64_TYPE) || defined(_LP64))
165
162
__DRIZZLE_DECL_ATOMIC(long long)
166
163
__DRIZZLE_DECL_ATOMIC(unsigned long long)
167
164
#  else