← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/atomic/gcc_traits.h

  • Committer: Jay Pipes
  • Date: 2010-04-08 16:27:25 UTC
  • mfrom: (1405.6.10 replication-pairs)
  • mto: This revision was merged to the branch mainline in revision 1457.
  • Revision ID: jpipes@serialcoder-20100408162725-sugbgn38oxjqclq2
Merge trunk and replication-pairs with conflict resolution

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/atomic/gcc_traits.h
32
32
 
33
33
  gcc_traits() {}
34
34
 
35
 
  /* YES. I know these are semantically backwards...
36
 
   * so... TODO: Ensure we're doing the "right" thing here
37
 
   */
 
35
  inline value_type add_and_fetch(volatile value_type *value, D addend )
 
36
  {
 
37
    return __sync_add_and_fetch(value, addend);
 
38
  }
 
39
 
38
40
  inline value_type fetch_and_add(volatile value_type *value, D addend )
39
41
  {
40
 
    return __sync_add_and_fetch(value, addend);
 
42
    return __sync_fetch_and_add(value, addend);
41
43
  }
42
44
 
43
45
  inline value_type fetch_and_increment(volatile value_type *value)
44
46
  {
45
 
    return __sync_add_and_fetch(value, 1);
 
47
    return __sync_fetch_and_add(value, 1);
46
48
  }
47
49
 
48
50
  inline value_type fetch_and_decrement(volatile value_type *value)
49
51
  {
50
 
    return __sync_sub_and_fetch(value, 1);
 
52
    return __sync_fetch_and_sub(value, 1);
51
53
  }
52
54
 
53
55
  inline value_type fetch_and_store(volatile value_type *value,
54
56
                                    value_type new_value)
55
57
  {
56
 
    /* TODO: Is this the right one? */
57
58
    return __sync_lock_test_and_set(value, new_value);
58
59
  }
59
60
 
60
 
  inline value_type compare_and_swap(volatile value_type *value,
 
61
  inline bool compare_and_swap(volatile value_type *value,
61
62
                                     value_type new_value,
62
63
                                     value_type comparand )
63
64
  {
64
 
    return __sync_val_compare_and_swap(value, comparand, new_value);
 
65
    return __sync_bool_compare_and_swap(value, comparand, new_value);
65
66
  }
66
67
 
67
68
  inline value_type fetch(const volatile value_type *value) const volatile
76
77
     * Look at how to rewrite the below to something that ICC feels is
77
78
     * OK and yet respects memory barriers.
78
79
     */
79
 
    return __sync_add_and_fetch(const_cast<value_type *>(value), 0);
 
80
    return __sync_fetch_and_add(const_cast<value_type *>(value), 0);
80
81
  }
81
82
 
82
83
  inline value_type store_with_release(volatile value_type *value,