← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/atomics.h

  • Committer: Brian Aker
  • Date: 2009-10-07 16:55:53 UTC
  • mfrom: (1161.2.1 bug444827)
  • Revision ID: brian@gaz-20091007165553-9tnp7liw1k9g6gvc
Merge Padraig

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/atomics.h
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2009 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2009 Sun Microsystems
5
5
 *  Copyright 2005-2008 Intel Corporation.  All Rights Reserved.
6
6
 *
7
7
 *  This program is free software; you can redistribute it and/or modify
24
24
# if defined(__SUNPRO_CC)
25
25
#  include <drizzled/atomic/sun_studio.h>
26
26
# endif
27
 
# if !defined(__ICC) && !defined(__clang__) && (defined(HAVE_GCC_ATOMIC_BUILTINS) || defined(__SUNPRO_CC))
 
27
# if !defined(__ICC) && (defined(HAVE_GCC_ATOMIC_BUILTINS) || defined(__SUNPRO_CC))
28
28
#  include <drizzled/atomic/gcc_traits.h>
29
29
#  define ATOMIC_TRAITS internal::gcc_traits
30
30
# else  /* use pthread impl */
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)) || defined(__ppc__)
 
34
# if (SIZEOF_SIZE_T >= SIZEOF_LONG_LONG) || (!defined(HAVE_GCC_ATOMIC_BUILTINS) || !defined(__SUNPRO_CC))
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() {}
50
48
};
51
49
 
52
50
template<typename I, typename D, typename T >
56
54
public:
57
55
  typedef I value_type;
58
56
 
59
 
  atomic_impl() : atomic_base<I>(), traits() {}
60
 
 
61
 
  value_type add_and_fetch( D addend )
62
 
  {
63
 
    return traits.add_and_fetch(&this->my_value, addend);
64
 
  }
65
57
 
66
58
  value_type fetch_and_add( D addend )
67
59
  {
83
75
    return traits.fetch_and_store(&this->my_value, value);
84
76
  }
85
77
 
86
 
  bool compare_and_swap( value_type value, value_type comparand )
 
78
  value_type compare_and_swap( value_type value, value_type comparand )
87
79
  {
88
80
    return traits.compare_and_swap(&this->my_value, value, comparand);
89
81
  }
105
97
  }
106
98
 
107
99
public:
108
 
  atomic_impl<I,D,T>& operator+=( D addend )
 
100
  value_type operator+=( D addend )
109
101
  {
110
 
    increment(addend);
111
 
    return *this;
 
102
      return fetch_and_add(addend)+addend;
112
103
  }
113
104
 
114
 
  atomic_impl<I,D,T>& operator-=( D addend )
 
105
  value_type operator-=( D addend )
115
106
  {
116
107
    // Additive inverse of addend computed using binary minus,
117
108
    // instead of unary minus, for sake of avoiding compiler warnings.
118
109
    return operator+=(D(0)-addend);
119
110
  }
120
111
 
121
 
  value_type increment()
122
 
  {
123
 
    return add_and_fetch(1);
124
 
  }
125
 
 
126
 
  value_type decrement()
127
 
  {
128
 
    return add_and_fetch(D(-1));
129
 
  }
 
112
  value_type operator++() {
 
113
    return fetch_and_add(1)+1;
 
114
  }
 
115
 
 
116
  value_type operator--() {
 
117
    return fetch_and_add(D(-1))-1;
 
118
  }
 
119
 
 
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
 
130
128
};
131
129
 
132
130
} /* namespace internal */
138
136
struct atomic {
139
137
};
140
138
 
141
 
/* *INDENT-OFF* */
142
139
#define __DRIZZLE_DECL_ATOMIC(T)                                        \
143
140
  template<> struct atomic<T>                                           \
144
141
  : internal::atomic_impl<T,T,ATOMIC_TRAITS<T,T> > {                    \
145
142
    atomic<T>() : internal::atomic_impl<T,T,ATOMIC_TRAITS<T,T> >() {}   \
146
 
    atomic<T>& operator=( T rhs ) { store_with_release(rhs); return *this; } \
 
143
    T operator=( T rhs ) { return store_with_release(rhs); }            \
147
144
  };
148
 
/* *INDENT-ON* */
149
145
 
150
146
 
151
147
__DRIZZLE_DECL_ATOMIC(long)
162
158
/* 32-bit platforms don't have a GCC atomic operation for 64-bit types,
163
159
 * so we'll use pthread locks to handler 64-bit types on that platforms
164
160
 */
165
 
/* *INDENT-OFF* */
166
 
# if !defined(__ppc__) && (defined(_INT64_TYPE) || defined(_LP64))
 
161
#  if SIZEOF_SIZE_T >= SIZEOF_LONG_LONG
167
162
__DRIZZLE_DECL_ATOMIC(long long)
168
163
__DRIZZLE_DECL_ATOMIC(unsigned long long)
169
164
#  else
177
172
__DRIZZLE_DECL_ATOMIC64(long long)
178
173
__DRIZZLE_DECL_ATOMIC64(unsigned long long)
179
174
#  endif
180
 
/* *INDENT-ON* */
181
175
 
182
176
}
183
177
 
184
 
#endif /* DRIZZLED_ATOMICS_H */
 
178
#endif /* DRIZZLED_ATOMIC_H */