forked from trdtnguyen/mysql-plnvm
-
Notifications
You must be signed in to change notification settings - Fork 3
/
Copy pathatomic_class.h
117 lines (108 loc) · 7.12 KB
/
atomic_class.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
/* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; version 2 of the
License.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
02110-1301 USA */
#ifndef ATOMIC_CLASS_H_INCLUDED
#define ATOMIC_CLASS_H_INCLUDED
#include "my_atomic.h"
/**
Wrapper class to use C++ syntax to access atomic integers.
*/
#define DEFINE_ATOMIC_CLASS(NAME, SUFFIX, TYPE) \
class Atomic_##NAME \
{ \
public: \
/* Create a new Atomic_* object. */ \
Atomic_##NAME(TYPE n= 0) \
{ \
my_atomic_store##SUFFIX(&value, n); \
} \
/* Atomically read the value. */ \
TYPE atomic_get() \
{ \
return my_atomic_load##SUFFIX(&value); \
} \
/* Atomically set the value. */ \
void atomic_set(TYPE n) \
{ \
my_atomic_store##SUFFIX(&value, n); \
} \
/* Atomically add to the value, and return the old value. */ \
TYPE atomic_add(TYPE n) \
{ \
return my_atomic_add##SUFFIX(&value, n); \
} \
/* Atomically set the value and return the old value. */ \
TYPE atomic_get_and_set(TYPE n) \
{ \
return my_atomic_fas##SUFFIX(&value, n); \
} \
/* If the old value is equal to *old, set the value to new and */ \
/* return true. Otherwise, store the old value in '*old' and */ \
/* return false. */ \
bool atomic_compare_and_swap(TYPE *old, TYPE n) \
{ \
return my_atomic_cas##SUFFIX(&value, old, n); \
} \
/* Read the value *non-atomically*. */ \
TYPE non_atomic_get() \
{ \
return value; \
} \
/* Set the value *non-atomically*. */ \
void non_atomic_set(TYPE n) \
{ \
value= n; \
} \
/* Add to the value *non-atomically*. */ \
TYPE non_atomic_add(TYPE n) \
{ \
TYPE ret= value; \
value+= n; \
return ret; \
} \
/* Set the value to the greatest of (old, n). */ \
\
/* The function will internally requires multiple atomic */ \
/* operations. If the old value is known (or guessed), and less */ \
/* than n, it requires one atomic operation less. Therefore, */ \
/* the caller should set *guess to whatever is the likely value */ \
/* that the variable currently has, if such a guess is known. */ \
\
/* @return If the new value is changed to n, *guess is set to */ \
/* the old value and the the function returns true. Otherwise, */ \
/* *guess is set to the current value (which is greater than or */ \
/* equal to n), and the function returns false. */ \
bool atomic_set_to_max(TYPE n, TYPE *guess= NULL) \
{ \
TYPE _guess; \
if (guess == NULL) \
{ \
_guess= n - 1; \
guess= &_guess; \
} \
else \
DBUG_ASSERT(*guess < n); \
bool ret; \
do { \
ret= atomic_compare_and_swap(guess, n); \
} while (!ret && *guess < n); \
return ret; \
} \
\
private: \
TYPE value; \
}
DEFINE_ATOMIC_CLASS(int32, 32, int32);
DEFINE_ATOMIC_CLASS(int64, 64, int64);
//DEFINE_ATOMIC_CLASS(pointer, ptr, void *);
#endif //ifndef ATOMIC_CLASS_H_INCLUDED